1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package macie2 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/macie2/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsRestjson1_deserializeOpAcceptInvitation struct { 23} 24 25func (*awsRestjson1_deserializeOpAcceptInvitation) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpAcceptInvitation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsRestjson1_deserializeOpErrorAcceptInvitation(response, &metadata) 44 } 45 output := &AcceptInvitationOutput{} 46 out.Result = output 47 48 return out, metadata, err 49} 50 51func awsRestjson1_deserializeOpErrorAcceptInvitation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 52 var errorBuffer bytes.Buffer 53 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 54 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 55 } 56 errorBody := bytes.NewReader(errorBuffer.Bytes()) 57 58 errorCode := "UnknownError" 59 errorMessage := errorCode 60 61 code := response.Header.Get("X-Amzn-ErrorType") 62 if len(code) != 0 { 63 errorCode = restjson.SanitizeErrorCode(code) 64 } 65 66 var buff [1024]byte 67 ringBuffer := smithyio.NewRingBuffer(buff[:]) 68 69 body := io.TeeReader(errorBody, ringBuffer) 70 decoder := json.NewDecoder(body) 71 decoder.UseNumber() 72 code, message, err := restjson.GetErrorInfo(decoder) 73 if err != nil { 74 var snapshot bytes.Buffer 75 io.Copy(&snapshot, ringBuffer) 76 err = &smithy.DeserializationError{ 77 Err: fmt.Errorf("failed to decode response body, %w", err), 78 Snapshot: snapshot.Bytes(), 79 } 80 return err 81 } 82 83 errorBody.Seek(0, io.SeekStart) 84 if len(code) != 0 { 85 errorCode = restjson.SanitizeErrorCode(code) 86 } 87 if len(message) != 0 { 88 errorMessage = message 89 } 90 91 switch { 92 case strings.EqualFold("AccessDeniedException", errorCode): 93 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 94 95 case strings.EqualFold("ConflictException", errorCode): 96 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 97 98 case strings.EqualFold("InternalServerException", errorCode): 99 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 100 101 case strings.EqualFold("ResourceNotFoundException", errorCode): 102 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 103 104 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 105 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 106 107 case strings.EqualFold("ThrottlingException", errorCode): 108 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 109 110 case strings.EqualFold("ValidationException", errorCode): 111 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 112 113 default: 114 genericError := &smithy.GenericAPIError{ 115 Code: errorCode, 116 Message: errorMessage, 117 } 118 return genericError 119 120 } 121} 122 123type awsRestjson1_deserializeOpBatchGetCustomDataIdentifiers struct { 124} 125 126func (*awsRestjson1_deserializeOpBatchGetCustomDataIdentifiers) ID() string { 127 return "OperationDeserializer" 128} 129 130func (m *awsRestjson1_deserializeOpBatchGetCustomDataIdentifiers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 131 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 132) { 133 out, metadata, err = next.HandleDeserialize(ctx, in) 134 if err != nil { 135 return out, metadata, err 136 } 137 138 response, ok := out.RawResponse.(*smithyhttp.Response) 139 if !ok { 140 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 141 } 142 143 if response.StatusCode < 200 || response.StatusCode >= 300 { 144 return out, metadata, awsRestjson1_deserializeOpErrorBatchGetCustomDataIdentifiers(response, &metadata) 145 } 146 output := &BatchGetCustomDataIdentifiersOutput{} 147 out.Result = output 148 149 var buff [1024]byte 150 ringBuffer := smithyio.NewRingBuffer(buff[:]) 151 152 body := io.TeeReader(response.Body, ringBuffer) 153 154 decoder := json.NewDecoder(body) 155 decoder.UseNumber() 156 var shape interface{} 157 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 158 var snapshot bytes.Buffer 159 io.Copy(&snapshot, ringBuffer) 160 err = &smithy.DeserializationError{ 161 Err: fmt.Errorf("failed to decode response body, %w", err), 162 Snapshot: snapshot.Bytes(), 163 } 164 return out, metadata, err 165 } 166 167 err = awsRestjson1_deserializeOpDocumentBatchGetCustomDataIdentifiersOutput(&output, shape) 168 if err != nil { 169 var snapshot bytes.Buffer 170 io.Copy(&snapshot, ringBuffer) 171 return out, metadata, &smithy.DeserializationError{ 172 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 173 Snapshot: snapshot.Bytes(), 174 } 175 } 176 177 return out, metadata, err 178} 179 180func awsRestjson1_deserializeOpErrorBatchGetCustomDataIdentifiers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 181 var errorBuffer bytes.Buffer 182 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 183 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 184 } 185 errorBody := bytes.NewReader(errorBuffer.Bytes()) 186 187 errorCode := "UnknownError" 188 errorMessage := errorCode 189 190 code := response.Header.Get("X-Amzn-ErrorType") 191 if len(code) != 0 { 192 errorCode = restjson.SanitizeErrorCode(code) 193 } 194 195 var buff [1024]byte 196 ringBuffer := smithyio.NewRingBuffer(buff[:]) 197 198 body := io.TeeReader(errorBody, ringBuffer) 199 decoder := json.NewDecoder(body) 200 decoder.UseNumber() 201 code, message, err := restjson.GetErrorInfo(decoder) 202 if err != nil { 203 var snapshot bytes.Buffer 204 io.Copy(&snapshot, ringBuffer) 205 err = &smithy.DeserializationError{ 206 Err: fmt.Errorf("failed to decode response body, %w", err), 207 Snapshot: snapshot.Bytes(), 208 } 209 return err 210 } 211 212 errorBody.Seek(0, io.SeekStart) 213 if len(code) != 0 { 214 errorCode = restjson.SanitizeErrorCode(code) 215 } 216 if len(message) != 0 { 217 errorMessage = message 218 } 219 220 switch { 221 case strings.EqualFold("AccessDeniedException", errorCode): 222 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 223 224 case strings.EqualFold("ConflictException", errorCode): 225 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 226 227 case strings.EqualFold("InternalServerException", errorCode): 228 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 229 230 case strings.EqualFold("ResourceNotFoundException", errorCode): 231 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 232 233 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 234 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 235 236 case strings.EqualFold("ThrottlingException", errorCode): 237 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 238 239 case strings.EqualFold("ValidationException", errorCode): 240 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 241 242 default: 243 genericError := &smithy.GenericAPIError{ 244 Code: errorCode, 245 Message: errorMessage, 246 } 247 return genericError 248 249 } 250} 251 252func awsRestjson1_deserializeOpDocumentBatchGetCustomDataIdentifiersOutput(v **BatchGetCustomDataIdentifiersOutput, value interface{}) error { 253 if v == nil { 254 return fmt.Errorf("unexpected nil of type %T", v) 255 } 256 if value == nil { 257 return nil 258 } 259 260 shape, ok := value.(map[string]interface{}) 261 if !ok { 262 return fmt.Errorf("unexpected JSON type %v", value) 263 } 264 265 var sv *BatchGetCustomDataIdentifiersOutput 266 if *v == nil { 267 sv = &BatchGetCustomDataIdentifiersOutput{} 268 } else { 269 sv = *v 270 } 271 272 for key, value := range shape { 273 switch key { 274 case "customDataIdentifiers": 275 if err := awsRestjson1_deserializeDocument__listOfBatchGetCustomDataIdentifierSummary(&sv.CustomDataIdentifiers, value); err != nil { 276 return err 277 } 278 279 case "notFoundIdentifierIds": 280 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.NotFoundIdentifierIds, value); err != nil { 281 return err 282 } 283 284 default: 285 _, _ = key, value 286 287 } 288 } 289 *v = sv 290 return nil 291} 292 293type awsRestjson1_deserializeOpCreateClassificationJob struct { 294} 295 296func (*awsRestjson1_deserializeOpCreateClassificationJob) ID() string { 297 return "OperationDeserializer" 298} 299 300func (m *awsRestjson1_deserializeOpCreateClassificationJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 301 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 302) { 303 out, metadata, err = next.HandleDeserialize(ctx, in) 304 if err != nil { 305 return out, metadata, err 306 } 307 308 response, ok := out.RawResponse.(*smithyhttp.Response) 309 if !ok { 310 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 311 } 312 313 if response.StatusCode < 200 || response.StatusCode >= 300 { 314 return out, metadata, awsRestjson1_deserializeOpErrorCreateClassificationJob(response, &metadata) 315 } 316 output := &CreateClassificationJobOutput{} 317 out.Result = output 318 319 var buff [1024]byte 320 ringBuffer := smithyio.NewRingBuffer(buff[:]) 321 322 body := io.TeeReader(response.Body, ringBuffer) 323 324 decoder := json.NewDecoder(body) 325 decoder.UseNumber() 326 var shape interface{} 327 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 328 var snapshot bytes.Buffer 329 io.Copy(&snapshot, ringBuffer) 330 err = &smithy.DeserializationError{ 331 Err: fmt.Errorf("failed to decode response body, %w", err), 332 Snapshot: snapshot.Bytes(), 333 } 334 return out, metadata, err 335 } 336 337 err = awsRestjson1_deserializeOpDocumentCreateClassificationJobOutput(&output, shape) 338 if err != nil { 339 var snapshot bytes.Buffer 340 io.Copy(&snapshot, ringBuffer) 341 return out, metadata, &smithy.DeserializationError{ 342 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 343 Snapshot: snapshot.Bytes(), 344 } 345 } 346 347 return out, metadata, err 348} 349 350func awsRestjson1_deserializeOpErrorCreateClassificationJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 351 var errorBuffer bytes.Buffer 352 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 353 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 354 } 355 errorBody := bytes.NewReader(errorBuffer.Bytes()) 356 357 errorCode := "UnknownError" 358 errorMessage := errorCode 359 360 code := response.Header.Get("X-Amzn-ErrorType") 361 if len(code) != 0 { 362 errorCode = restjson.SanitizeErrorCode(code) 363 } 364 365 var buff [1024]byte 366 ringBuffer := smithyio.NewRingBuffer(buff[:]) 367 368 body := io.TeeReader(errorBody, ringBuffer) 369 decoder := json.NewDecoder(body) 370 decoder.UseNumber() 371 code, message, err := restjson.GetErrorInfo(decoder) 372 if err != nil { 373 var snapshot bytes.Buffer 374 io.Copy(&snapshot, ringBuffer) 375 err = &smithy.DeserializationError{ 376 Err: fmt.Errorf("failed to decode response body, %w", err), 377 Snapshot: snapshot.Bytes(), 378 } 379 return err 380 } 381 382 errorBody.Seek(0, io.SeekStart) 383 if len(code) != 0 { 384 errorCode = restjson.SanitizeErrorCode(code) 385 } 386 if len(message) != 0 { 387 errorMessage = message 388 } 389 390 switch { 391 case strings.EqualFold("AccessDeniedException", errorCode): 392 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 393 394 case strings.EqualFold("ConflictException", errorCode): 395 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 396 397 case strings.EqualFold("InternalServerException", errorCode): 398 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 399 400 case strings.EqualFold("ResourceNotFoundException", errorCode): 401 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 402 403 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 404 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 405 406 case strings.EqualFold("ThrottlingException", errorCode): 407 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 408 409 case strings.EqualFold("ValidationException", errorCode): 410 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 411 412 default: 413 genericError := &smithy.GenericAPIError{ 414 Code: errorCode, 415 Message: errorMessage, 416 } 417 return genericError 418 419 } 420} 421 422func awsRestjson1_deserializeOpDocumentCreateClassificationJobOutput(v **CreateClassificationJobOutput, value interface{}) error { 423 if v == nil { 424 return fmt.Errorf("unexpected nil of type %T", v) 425 } 426 if value == nil { 427 return nil 428 } 429 430 shape, ok := value.(map[string]interface{}) 431 if !ok { 432 return fmt.Errorf("unexpected JSON type %v", value) 433 } 434 435 var sv *CreateClassificationJobOutput 436 if *v == nil { 437 sv = &CreateClassificationJobOutput{} 438 } else { 439 sv = *v 440 } 441 442 for key, value := range shape { 443 switch key { 444 case "jobArn": 445 if value != nil { 446 jtv, ok := value.(string) 447 if !ok { 448 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 449 } 450 sv.JobArn = ptr.String(jtv) 451 } 452 453 case "jobId": 454 if value != nil { 455 jtv, ok := value.(string) 456 if !ok { 457 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 458 } 459 sv.JobId = ptr.String(jtv) 460 } 461 462 default: 463 _, _ = key, value 464 465 } 466 } 467 *v = sv 468 return nil 469} 470 471type awsRestjson1_deserializeOpCreateCustomDataIdentifier struct { 472} 473 474func (*awsRestjson1_deserializeOpCreateCustomDataIdentifier) ID() string { 475 return "OperationDeserializer" 476} 477 478func (m *awsRestjson1_deserializeOpCreateCustomDataIdentifier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 479 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 480) { 481 out, metadata, err = next.HandleDeserialize(ctx, in) 482 if err != nil { 483 return out, metadata, err 484 } 485 486 response, ok := out.RawResponse.(*smithyhttp.Response) 487 if !ok { 488 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 489 } 490 491 if response.StatusCode < 200 || response.StatusCode >= 300 { 492 return out, metadata, awsRestjson1_deserializeOpErrorCreateCustomDataIdentifier(response, &metadata) 493 } 494 output := &CreateCustomDataIdentifierOutput{} 495 out.Result = output 496 497 var buff [1024]byte 498 ringBuffer := smithyio.NewRingBuffer(buff[:]) 499 500 body := io.TeeReader(response.Body, ringBuffer) 501 502 decoder := json.NewDecoder(body) 503 decoder.UseNumber() 504 var shape interface{} 505 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 506 var snapshot bytes.Buffer 507 io.Copy(&snapshot, ringBuffer) 508 err = &smithy.DeserializationError{ 509 Err: fmt.Errorf("failed to decode response body, %w", err), 510 Snapshot: snapshot.Bytes(), 511 } 512 return out, metadata, err 513 } 514 515 err = awsRestjson1_deserializeOpDocumentCreateCustomDataIdentifierOutput(&output, shape) 516 if err != nil { 517 var snapshot bytes.Buffer 518 io.Copy(&snapshot, ringBuffer) 519 return out, metadata, &smithy.DeserializationError{ 520 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 521 Snapshot: snapshot.Bytes(), 522 } 523 } 524 525 return out, metadata, err 526} 527 528func awsRestjson1_deserializeOpErrorCreateCustomDataIdentifier(response *smithyhttp.Response, metadata *middleware.Metadata) error { 529 var errorBuffer bytes.Buffer 530 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 531 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 532 } 533 errorBody := bytes.NewReader(errorBuffer.Bytes()) 534 535 errorCode := "UnknownError" 536 errorMessage := errorCode 537 538 code := response.Header.Get("X-Amzn-ErrorType") 539 if len(code) != 0 { 540 errorCode = restjson.SanitizeErrorCode(code) 541 } 542 543 var buff [1024]byte 544 ringBuffer := smithyio.NewRingBuffer(buff[:]) 545 546 body := io.TeeReader(errorBody, ringBuffer) 547 decoder := json.NewDecoder(body) 548 decoder.UseNumber() 549 code, message, err := restjson.GetErrorInfo(decoder) 550 if err != nil { 551 var snapshot bytes.Buffer 552 io.Copy(&snapshot, ringBuffer) 553 err = &smithy.DeserializationError{ 554 Err: fmt.Errorf("failed to decode response body, %w", err), 555 Snapshot: snapshot.Bytes(), 556 } 557 return err 558 } 559 560 errorBody.Seek(0, io.SeekStart) 561 if len(code) != 0 { 562 errorCode = restjson.SanitizeErrorCode(code) 563 } 564 if len(message) != 0 { 565 errorMessage = message 566 } 567 568 switch { 569 case strings.EqualFold("AccessDeniedException", errorCode): 570 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 571 572 case strings.EqualFold("ConflictException", errorCode): 573 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 574 575 case strings.EqualFold("InternalServerException", errorCode): 576 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 577 578 case strings.EqualFold("ResourceNotFoundException", errorCode): 579 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 580 581 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 582 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 583 584 case strings.EqualFold("ThrottlingException", errorCode): 585 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 586 587 case strings.EqualFold("ValidationException", errorCode): 588 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 589 590 default: 591 genericError := &smithy.GenericAPIError{ 592 Code: errorCode, 593 Message: errorMessage, 594 } 595 return genericError 596 597 } 598} 599 600func awsRestjson1_deserializeOpDocumentCreateCustomDataIdentifierOutput(v **CreateCustomDataIdentifierOutput, value interface{}) error { 601 if v == nil { 602 return fmt.Errorf("unexpected nil of type %T", v) 603 } 604 if value == nil { 605 return nil 606 } 607 608 shape, ok := value.(map[string]interface{}) 609 if !ok { 610 return fmt.Errorf("unexpected JSON type %v", value) 611 } 612 613 var sv *CreateCustomDataIdentifierOutput 614 if *v == nil { 615 sv = &CreateCustomDataIdentifierOutput{} 616 } else { 617 sv = *v 618 } 619 620 for key, value := range shape { 621 switch key { 622 case "customDataIdentifierId": 623 if value != nil { 624 jtv, ok := value.(string) 625 if !ok { 626 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 627 } 628 sv.CustomDataIdentifierId = ptr.String(jtv) 629 } 630 631 default: 632 _, _ = key, value 633 634 } 635 } 636 *v = sv 637 return nil 638} 639 640type awsRestjson1_deserializeOpCreateFindingsFilter struct { 641} 642 643func (*awsRestjson1_deserializeOpCreateFindingsFilter) ID() string { 644 return "OperationDeserializer" 645} 646 647func (m *awsRestjson1_deserializeOpCreateFindingsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 648 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 649) { 650 out, metadata, err = next.HandleDeserialize(ctx, in) 651 if err != nil { 652 return out, metadata, err 653 } 654 655 response, ok := out.RawResponse.(*smithyhttp.Response) 656 if !ok { 657 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 658 } 659 660 if response.StatusCode < 200 || response.StatusCode >= 300 { 661 return out, metadata, awsRestjson1_deserializeOpErrorCreateFindingsFilter(response, &metadata) 662 } 663 output := &CreateFindingsFilterOutput{} 664 out.Result = output 665 666 var buff [1024]byte 667 ringBuffer := smithyio.NewRingBuffer(buff[:]) 668 669 body := io.TeeReader(response.Body, ringBuffer) 670 671 decoder := json.NewDecoder(body) 672 decoder.UseNumber() 673 var shape interface{} 674 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 675 var snapshot bytes.Buffer 676 io.Copy(&snapshot, ringBuffer) 677 err = &smithy.DeserializationError{ 678 Err: fmt.Errorf("failed to decode response body, %w", err), 679 Snapshot: snapshot.Bytes(), 680 } 681 return out, metadata, err 682 } 683 684 err = awsRestjson1_deserializeOpDocumentCreateFindingsFilterOutput(&output, shape) 685 if err != nil { 686 var snapshot bytes.Buffer 687 io.Copy(&snapshot, ringBuffer) 688 return out, metadata, &smithy.DeserializationError{ 689 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 690 Snapshot: snapshot.Bytes(), 691 } 692 } 693 694 return out, metadata, err 695} 696 697func awsRestjson1_deserializeOpErrorCreateFindingsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 698 var errorBuffer bytes.Buffer 699 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 700 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 701 } 702 errorBody := bytes.NewReader(errorBuffer.Bytes()) 703 704 errorCode := "UnknownError" 705 errorMessage := errorCode 706 707 code := response.Header.Get("X-Amzn-ErrorType") 708 if len(code) != 0 { 709 errorCode = restjson.SanitizeErrorCode(code) 710 } 711 712 var buff [1024]byte 713 ringBuffer := smithyio.NewRingBuffer(buff[:]) 714 715 body := io.TeeReader(errorBody, ringBuffer) 716 decoder := json.NewDecoder(body) 717 decoder.UseNumber() 718 code, message, err := restjson.GetErrorInfo(decoder) 719 if err != nil { 720 var snapshot bytes.Buffer 721 io.Copy(&snapshot, ringBuffer) 722 err = &smithy.DeserializationError{ 723 Err: fmt.Errorf("failed to decode response body, %w", err), 724 Snapshot: snapshot.Bytes(), 725 } 726 return err 727 } 728 729 errorBody.Seek(0, io.SeekStart) 730 if len(code) != 0 { 731 errorCode = restjson.SanitizeErrorCode(code) 732 } 733 if len(message) != 0 { 734 errorMessage = message 735 } 736 737 switch { 738 case strings.EqualFold("AccessDeniedException", errorCode): 739 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 740 741 case strings.EqualFold("ConflictException", errorCode): 742 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 743 744 case strings.EqualFold("InternalServerException", errorCode): 745 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 746 747 case strings.EqualFold("ResourceNotFoundException", errorCode): 748 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 749 750 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 751 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 752 753 case strings.EqualFold("ThrottlingException", errorCode): 754 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 755 756 case strings.EqualFold("ValidationException", errorCode): 757 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 758 759 default: 760 genericError := &smithy.GenericAPIError{ 761 Code: errorCode, 762 Message: errorMessage, 763 } 764 return genericError 765 766 } 767} 768 769func awsRestjson1_deserializeOpDocumentCreateFindingsFilterOutput(v **CreateFindingsFilterOutput, value interface{}) error { 770 if v == nil { 771 return fmt.Errorf("unexpected nil of type %T", v) 772 } 773 if value == nil { 774 return nil 775 } 776 777 shape, ok := value.(map[string]interface{}) 778 if !ok { 779 return fmt.Errorf("unexpected JSON type %v", value) 780 } 781 782 var sv *CreateFindingsFilterOutput 783 if *v == nil { 784 sv = &CreateFindingsFilterOutput{} 785 } else { 786 sv = *v 787 } 788 789 for key, value := range shape { 790 switch key { 791 case "arn": 792 if value != nil { 793 jtv, ok := value.(string) 794 if !ok { 795 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 796 } 797 sv.Arn = ptr.String(jtv) 798 } 799 800 case "id": 801 if value != nil { 802 jtv, ok := value.(string) 803 if !ok { 804 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 805 } 806 sv.Id = ptr.String(jtv) 807 } 808 809 default: 810 _, _ = key, value 811 812 } 813 } 814 *v = sv 815 return nil 816} 817 818type awsRestjson1_deserializeOpCreateInvitations struct { 819} 820 821func (*awsRestjson1_deserializeOpCreateInvitations) ID() string { 822 return "OperationDeserializer" 823} 824 825func (m *awsRestjson1_deserializeOpCreateInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 826 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 827) { 828 out, metadata, err = next.HandleDeserialize(ctx, in) 829 if err != nil { 830 return out, metadata, err 831 } 832 833 response, ok := out.RawResponse.(*smithyhttp.Response) 834 if !ok { 835 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 836 } 837 838 if response.StatusCode < 200 || response.StatusCode >= 300 { 839 return out, metadata, awsRestjson1_deserializeOpErrorCreateInvitations(response, &metadata) 840 } 841 output := &CreateInvitationsOutput{} 842 out.Result = output 843 844 var buff [1024]byte 845 ringBuffer := smithyio.NewRingBuffer(buff[:]) 846 847 body := io.TeeReader(response.Body, ringBuffer) 848 849 decoder := json.NewDecoder(body) 850 decoder.UseNumber() 851 var shape interface{} 852 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 853 var snapshot bytes.Buffer 854 io.Copy(&snapshot, ringBuffer) 855 err = &smithy.DeserializationError{ 856 Err: fmt.Errorf("failed to decode response body, %w", err), 857 Snapshot: snapshot.Bytes(), 858 } 859 return out, metadata, err 860 } 861 862 err = awsRestjson1_deserializeOpDocumentCreateInvitationsOutput(&output, shape) 863 if err != nil { 864 var snapshot bytes.Buffer 865 io.Copy(&snapshot, ringBuffer) 866 return out, metadata, &smithy.DeserializationError{ 867 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 868 Snapshot: snapshot.Bytes(), 869 } 870 } 871 872 return out, metadata, err 873} 874 875func awsRestjson1_deserializeOpErrorCreateInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 876 var errorBuffer bytes.Buffer 877 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 878 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 879 } 880 errorBody := bytes.NewReader(errorBuffer.Bytes()) 881 882 errorCode := "UnknownError" 883 errorMessage := errorCode 884 885 code := response.Header.Get("X-Amzn-ErrorType") 886 if len(code) != 0 { 887 errorCode = restjson.SanitizeErrorCode(code) 888 } 889 890 var buff [1024]byte 891 ringBuffer := smithyio.NewRingBuffer(buff[:]) 892 893 body := io.TeeReader(errorBody, ringBuffer) 894 decoder := json.NewDecoder(body) 895 decoder.UseNumber() 896 code, message, err := restjson.GetErrorInfo(decoder) 897 if err != nil { 898 var snapshot bytes.Buffer 899 io.Copy(&snapshot, ringBuffer) 900 err = &smithy.DeserializationError{ 901 Err: fmt.Errorf("failed to decode response body, %w", err), 902 Snapshot: snapshot.Bytes(), 903 } 904 return err 905 } 906 907 errorBody.Seek(0, io.SeekStart) 908 if len(code) != 0 { 909 errorCode = restjson.SanitizeErrorCode(code) 910 } 911 if len(message) != 0 { 912 errorMessage = message 913 } 914 915 switch { 916 case strings.EqualFold("AccessDeniedException", errorCode): 917 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 918 919 case strings.EqualFold("ConflictException", errorCode): 920 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 921 922 case strings.EqualFold("InternalServerException", errorCode): 923 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 924 925 case strings.EqualFold("ResourceNotFoundException", errorCode): 926 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 927 928 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 929 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 930 931 case strings.EqualFold("ThrottlingException", errorCode): 932 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 933 934 case strings.EqualFold("ValidationException", errorCode): 935 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 936 937 default: 938 genericError := &smithy.GenericAPIError{ 939 Code: errorCode, 940 Message: errorMessage, 941 } 942 return genericError 943 944 } 945} 946 947func awsRestjson1_deserializeOpDocumentCreateInvitationsOutput(v **CreateInvitationsOutput, value interface{}) error { 948 if v == nil { 949 return fmt.Errorf("unexpected nil of type %T", v) 950 } 951 if value == nil { 952 return nil 953 } 954 955 shape, ok := value.(map[string]interface{}) 956 if !ok { 957 return fmt.Errorf("unexpected JSON type %v", value) 958 } 959 960 var sv *CreateInvitationsOutput 961 if *v == nil { 962 sv = &CreateInvitationsOutput{} 963 } else { 964 sv = *v 965 } 966 967 for key, value := range shape { 968 switch key { 969 case "unprocessedAccounts": 970 if err := awsRestjson1_deserializeDocument__listOfUnprocessedAccount(&sv.UnprocessedAccounts, value); err != nil { 971 return err 972 } 973 974 default: 975 _, _ = key, value 976 977 } 978 } 979 *v = sv 980 return nil 981} 982 983type awsRestjson1_deserializeOpCreateMember struct { 984} 985 986func (*awsRestjson1_deserializeOpCreateMember) ID() string { 987 return "OperationDeserializer" 988} 989 990func (m *awsRestjson1_deserializeOpCreateMember) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 991 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 992) { 993 out, metadata, err = next.HandleDeserialize(ctx, in) 994 if err != nil { 995 return out, metadata, err 996 } 997 998 response, ok := out.RawResponse.(*smithyhttp.Response) 999 if !ok { 1000 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1001 } 1002 1003 if response.StatusCode < 200 || response.StatusCode >= 300 { 1004 return out, metadata, awsRestjson1_deserializeOpErrorCreateMember(response, &metadata) 1005 } 1006 output := &CreateMemberOutput{} 1007 out.Result = output 1008 1009 var buff [1024]byte 1010 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1011 1012 body := io.TeeReader(response.Body, ringBuffer) 1013 1014 decoder := json.NewDecoder(body) 1015 decoder.UseNumber() 1016 var shape interface{} 1017 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1018 var snapshot bytes.Buffer 1019 io.Copy(&snapshot, ringBuffer) 1020 err = &smithy.DeserializationError{ 1021 Err: fmt.Errorf("failed to decode response body, %w", err), 1022 Snapshot: snapshot.Bytes(), 1023 } 1024 return out, metadata, err 1025 } 1026 1027 err = awsRestjson1_deserializeOpDocumentCreateMemberOutput(&output, shape) 1028 if err != nil { 1029 var snapshot bytes.Buffer 1030 io.Copy(&snapshot, ringBuffer) 1031 return out, metadata, &smithy.DeserializationError{ 1032 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1033 Snapshot: snapshot.Bytes(), 1034 } 1035 } 1036 1037 return out, metadata, err 1038} 1039 1040func awsRestjson1_deserializeOpErrorCreateMember(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1041 var errorBuffer bytes.Buffer 1042 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1043 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1044 } 1045 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1046 1047 errorCode := "UnknownError" 1048 errorMessage := errorCode 1049 1050 code := response.Header.Get("X-Amzn-ErrorType") 1051 if len(code) != 0 { 1052 errorCode = restjson.SanitizeErrorCode(code) 1053 } 1054 1055 var buff [1024]byte 1056 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1057 1058 body := io.TeeReader(errorBody, ringBuffer) 1059 decoder := json.NewDecoder(body) 1060 decoder.UseNumber() 1061 code, message, err := restjson.GetErrorInfo(decoder) 1062 if err != nil { 1063 var snapshot bytes.Buffer 1064 io.Copy(&snapshot, ringBuffer) 1065 err = &smithy.DeserializationError{ 1066 Err: fmt.Errorf("failed to decode response body, %w", err), 1067 Snapshot: snapshot.Bytes(), 1068 } 1069 return err 1070 } 1071 1072 errorBody.Seek(0, io.SeekStart) 1073 if len(code) != 0 { 1074 errorCode = restjson.SanitizeErrorCode(code) 1075 } 1076 if len(message) != 0 { 1077 errorMessage = message 1078 } 1079 1080 switch { 1081 case strings.EqualFold("AccessDeniedException", errorCode): 1082 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1083 1084 case strings.EqualFold("ConflictException", errorCode): 1085 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1086 1087 case strings.EqualFold("InternalServerException", errorCode): 1088 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1089 1090 case strings.EqualFold("ResourceNotFoundException", errorCode): 1091 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1092 1093 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1094 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 1095 1096 case strings.EqualFold("ThrottlingException", errorCode): 1097 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1098 1099 case strings.EqualFold("ValidationException", errorCode): 1100 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1101 1102 default: 1103 genericError := &smithy.GenericAPIError{ 1104 Code: errorCode, 1105 Message: errorMessage, 1106 } 1107 return genericError 1108 1109 } 1110} 1111 1112func awsRestjson1_deserializeOpDocumentCreateMemberOutput(v **CreateMemberOutput, value interface{}) error { 1113 if v == nil { 1114 return fmt.Errorf("unexpected nil of type %T", v) 1115 } 1116 if value == nil { 1117 return nil 1118 } 1119 1120 shape, ok := value.(map[string]interface{}) 1121 if !ok { 1122 return fmt.Errorf("unexpected JSON type %v", value) 1123 } 1124 1125 var sv *CreateMemberOutput 1126 if *v == nil { 1127 sv = &CreateMemberOutput{} 1128 } else { 1129 sv = *v 1130 } 1131 1132 for key, value := range shape { 1133 switch key { 1134 case "arn": 1135 if value != nil { 1136 jtv, ok := value.(string) 1137 if !ok { 1138 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 1139 } 1140 sv.Arn = ptr.String(jtv) 1141 } 1142 1143 default: 1144 _, _ = key, value 1145 1146 } 1147 } 1148 *v = sv 1149 return nil 1150} 1151 1152type awsRestjson1_deserializeOpCreateSampleFindings struct { 1153} 1154 1155func (*awsRestjson1_deserializeOpCreateSampleFindings) ID() string { 1156 return "OperationDeserializer" 1157} 1158 1159func (m *awsRestjson1_deserializeOpCreateSampleFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1160 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1161) { 1162 out, metadata, err = next.HandleDeserialize(ctx, in) 1163 if err != nil { 1164 return out, metadata, err 1165 } 1166 1167 response, ok := out.RawResponse.(*smithyhttp.Response) 1168 if !ok { 1169 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1170 } 1171 1172 if response.StatusCode < 200 || response.StatusCode >= 300 { 1173 return out, metadata, awsRestjson1_deserializeOpErrorCreateSampleFindings(response, &metadata) 1174 } 1175 output := &CreateSampleFindingsOutput{} 1176 out.Result = output 1177 1178 return out, metadata, err 1179} 1180 1181func awsRestjson1_deserializeOpErrorCreateSampleFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1182 var errorBuffer bytes.Buffer 1183 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1184 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1185 } 1186 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1187 1188 errorCode := "UnknownError" 1189 errorMessage := errorCode 1190 1191 code := response.Header.Get("X-Amzn-ErrorType") 1192 if len(code) != 0 { 1193 errorCode = restjson.SanitizeErrorCode(code) 1194 } 1195 1196 var buff [1024]byte 1197 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1198 1199 body := io.TeeReader(errorBody, ringBuffer) 1200 decoder := json.NewDecoder(body) 1201 decoder.UseNumber() 1202 code, message, err := restjson.GetErrorInfo(decoder) 1203 if err != nil { 1204 var snapshot bytes.Buffer 1205 io.Copy(&snapshot, ringBuffer) 1206 err = &smithy.DeserializationError{ 1207 Err: fmt.Errorf("failed to decode response body, %w", err), 1208 Snapshot: snapshot.Bytes(), 1209 } 1210 return err 1211 } 1212 1213 errorBody.Seek(0, io.SeekStart) 1214 if len(code) != 0 { 1215 errorCode = restjson.SanitizeErrorCode(code) 1216 } 1217 if len(message) != 0 { 1218 errorMessage = message 1219 } 1220 1221 switch { 1222 case strings.EqualFold("AccessDeniedException", errorCode): 1223 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1224 1225 case strings.EqualFold("ConflictException", errorCode): 1226 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1227 1228 case strings.EqualFold("InternalServerException", errorCode): 1229 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1230 1231 case strings.EqualFold("ResourceNotFoundException", errorCode): 1232 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1233 1234 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1235 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 1236 1237 case strings.EqualFold("ThrottlingException", errorCode): 1238 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1239 1240 case strings.EqualFold("ValidationException", errorCode): 1241 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1242 1243 default: 1244 genericError := &smithy.GenericAPIError{ 1245 Code: errorCode, 1246 Message: errorMessage, 1247 } 1248 return genericError 1249 1250 } 1251} 1252 1253type awsRestjson1_deserializeOpDeclineInvitations struct { 1254} 1255 1256func (*awsRestjson1_deserializeOpDeclineInvitations) ID() string { 1257 return "OperationDeserializer" 1258} 1259 1260func (m *awsRestjson1_deserializeOpDeclineInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1262) { 1263 out, metadata, err = next.HandleDeserialize(ctx, in) 1264 if err != nil { 1265 return out, metadata, err 1266 } 1267 1268 response, ok := out.RawResponse.(*smithyhttp.Response) 1269 if !ok { 1270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1271 } 1272 1273 if response.StatusCode < 200 || response.StatusCode >= 300 { 1274 return out, metadata, awsRestjson1_deserializeOpErrorDeclineInvitations(response, &metadata) 1275 } 1276 output := &DeclineInvitationsOutput{} 1277 out.Result = output 1278 1279 var buff [1024]byte 1280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1281 1282 body := io.TeeReader(response.Body, ringBuffer) 1283 1284 decoder := json.NewDecoder(body) 1285 decoder.UseNumber() 1286 var shape interface{} 1287 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1288 var snapshot bytes.Buffer 1289 io.Copy(&snapshot, ringBuffer) 1290 err = &smithy.DeserializationError{ 1291 Err: fmt.Errorf("failed to decode response body, %w", err), 1292 Snapshot: snapshot.Bytes(), 1293 } 1294 return out, metadata, err 1295 } 1296 1297 err = awsRestjson1_deserializeOpDocumentDeclineInvitationsOutput(&output, shape) 1298 if err != nil { 1299 var snapshot bytes.Buffer 1300 io.Copy(&snapshot, ringBuffer) 1301 return out, metadata, &smithy.DeserializationError{ 1302 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1303 Snapshot: snapshot.Bytes(), 1304 } 1305 } 1306 1307 return out, metadata, err 1308} 1309 1310func awsRestjson1_deserializeOpErrorDeclineInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1311 var errorBuffer bytes.Buffer 1312 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1313 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1314 } 1315 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1316 1317 errorCode := "UnknownError" 1318 errorMessage := errorCode 1319 1320 code := response.Header.Get("X-Amzn-ErrorType") 1321 if len(code) != 0 { 1322 errorCode = restjson.SanitizeErrorCode(code) 1323 } 1324 1325 var buff [1024]byte 1326 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1327 1328 body := io.TeeReader(errorBody, ringBuffer) 1329 decoder := json.NewDecoder(body) 1330 decoder.UseNumber() 1331 code, message, err := restjson.GetErrorInfo(decoder) 1332 if err != nil { 1333 var snapshot bytes.Buffer 1334 io.Copy(&snapshot, ringBuffer) 1335 err = &smithy.DeserializationError{ 1336 Err: fmt.Errorf("failed to decode response body, %w", err), 1337 Snapshot: snapshot.Bytes(), 1338 } 1339 return err 1340 } 1341 1342 errorBody.Seek(0, io.SeekStart) 1343 if len(code) != 0 { 1344 errorCode = restjson.SanitizeErrorCode(code) 1345 } 1346 if len(message) != 0 { 1347 errorMessage = message 1348 } 1349 1350 switch { 1351 case strings.EqualFold("AccessDeniedException", errorCode): 1352 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1353 1354 case strings.EqualFold("ConflictException", errorCode): 1355 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1356 1357 case strings.EqualFold("InternalServerException", errorCode): 1358 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1359 1360 case strings.EqualFold("ResourceNotFoundException", errorCode): 1361 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1362 1363 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1364 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 1365 1366 case strings.EqualFold("ThrottlingException", errorCode): 1367 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1368 1369 case strings.EqualFold("ValidationException", errorCode): 1370 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1371 1372 default: 1373 genericError := &smithy.GenericAPIError{ 1374 Code: errorCode, 1375 Message: errorMessage, 1376 } 1377 return genericError 1378 1379 } 1380} 1381 1382func awsRestjson1_deserializeOpDocumentDeclineInvitationsOutput(v **DeclineInvitationsOutput, value interface{}) error { 1383 if v == nil { 1384 return fmt.Errorf("unexpected nil of type %T", v) 1385 } 1386 if value == nil { 1387 return nil 1388 } 1389 1390 shape, ok := value.(map[string]interface{}) 1391 if !ok { 1392 return fmt.Errorf("unexpected JSON type %v", value) 1393 } 1394 1395 var sv *DeclineInvitationsOutput 1396 if *v == nil { 1397 sv = &DeclineInvitationsOutput{} 1398 } else { 1399 sv = *v 1400 } 1401 1402 for key, value := range shape { 1403 switch key { 1404 case "unprocessedAccounts": 1405 if err := awsRestjson1_deserializeDocument__listOfUnprocessedAccount(&sv.UnprocessedAccounts, value); err != nil { 1406 return err 1407 } 1408 1409 default: 1410 _, _ = key, value 1411 1412 } 1413 } 1414 *v = sv 1415 return nil 1416} 1417 1418type awsRestjson1_deserializeOpDeleteCustomDataIdentifier struct { 1419} 1420 1421func (*awsRestjson1_deserializeOpDeleteCustomDataIdentifier) ID() string { 1422 return "OperationDeserializer" 1423} 1424 1425func (m *awsRestjson1_deserializeOpDeleteCustomDataIdentifier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1426 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1427) { 1428 out, metadata, err = next.HandleDeserialize(ctx, in) 1429 if err != nil { 1430 return out, metadata, err 1431 } 1432 1433 response, ok := out.RawResponse.(*smithyhttp.Response) 1434 if !ok { 1435 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1436 } 1437 1438 if response.StatusCode < 200 || response.StatusCode >= 300 { 1439 return out, metadata, awsRestjson1_deserializeOpErrorDeleteCustomDataIdentifier(response, &metadata) 1440 } 1441 output := &DeleteCustomDataIdentifierOutput{} 1442 out.Result = output 1443 1444 return out, metadata, err 1445} 1446 1447func awsRestjson1_deserializeOpErrorDeleteCustomDataIdentifier(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1448 var errorBuffer bytes.Buffer 1449 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1450 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1451 } 1452 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1453 1454 errorCode := "UnknownError" 1455 errorMessage := errorCode 1456 1457 code := response.Header.Get("X-Amzn-ErrorType") 1458 if len(code) != 0 { 1459 errorCode = restjson.SanitizeErrorCode(code) 1460 } 1461 1462 var buff [1024]byte 1463 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1464 1465 body := io.TeeReader(errorBody, ringBuffer) 1466 decoder := json.NewDecoder(body) 1467 decoder.UseNumber() 1468 code, message, err := restjson.GetErrorInfo(decoder) 1469 if err != nil { 1470 var snapshot bytes.Buffer 1471 io.Copy(&snapshot, ringBuffer) 1472 err = &smithy.DeserializationError{ 1473 Err: fmt.Errorf("failed to decode response body, %w", err), 1474 Snapshot: snapshot.Bytes(), 1475 } 1476 return err 1477 } 1478 1479 errorBody.Seek(0, io.SeekStart) 1480 if len(code) != 0 { 1481 errorCode = restjson.SanitizeErrorCode(code) 1482 } 1483 if len(message) != 0 { 1484 errorMessage = message 1485 } 1486 1487 switch { 1488 case strings.EqualFold("AccessDeniedException", errorCode): 1489 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1490 1491 case strings.EqualFold("ConflictException", errorCode): 1492 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1493 1494 case strings.EqualFold("InternalServerException", errorCode): 1495 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1496 1497 case strings.EqualFold("ResourceNotFoundException", errorCode): 1498 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1499 1500 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1501 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 1502 1503 case strings.EqualFold("ThrottlingException", errorCode): 1504 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1505 1506 case strings.EqualFold("ValidationException", errorCode): 1507 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1508 1509 default: 1510 genericError := &smithy.GenericAPIError{ 1511 Code: errorCode, 1512 Message: errorMessage, 1513 } 1514 return genericError 1515 1516 } 1517} 1518 1519type awsRestjson1_deserializeOpDeleteFindingsFilter struct { 1520} 1521 1522func (*awsRestjson1_deserializeOpDeleteFindingsFilter) ID() string { 1523 return "OperationDeserializer" 1524} 1525 1526func (m *awsRestjson1_deserializeOpDeleteFindingsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1527 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1528) { 1529 out, metadata, err = next.HandleDeserialize(ctx, in) 1530 if err != nil { 1531 return out, metadata, err 1532 } 1533 1534 response, ok := out.RawResponse.(*smithyhttp.Response) 1535 if !ok { 1536 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1537 } 1538 1539 if response.StatusCode < 200 || response.StatusCode >= 300 { 1540 return out, metadata, awsRestjson1_deserializeOpErrorDeleteFindingsFilter(response, &metadata) 1541 } 1542 output := &DeleteFindingsFilterOutput{} 1543 out.Result = output 1544 1545 return out, metadata, err 1546} 1547 1548func awsRestjson1_deserializeOpErrorDeleteFindingsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1549 var errorBuffer bytes.Buffer 1550 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1551 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1552 } 1553 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1554 1555 errorCode := "UnknownError" 1556 errorMessage := errorCode 1557 1558 code := response.Header.Get("X-Amzn-ErrorType") 1559 if len(code) != 0 { 1560 errorCode = restjson.SanitizeErrorCode(code) 1561 } 1562 1563 var buff [1024]byte 1564 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1565 1566 body := io.TeeReader(errorBody, ringBuffer) 1567 decoder := json.NewDecoder(body) 1568 decoder.UseNumber() 1569 code, message, err := restjson.GetErrorInfo(decoder) 1570 if err != nil { 1571 var snapshot bytes.Buffer 1572 io.Copy(&snapshot, ringBuffer) 1573 err = &smithy.DeserializationError{ 1574 Err: fmt.Errorf("failed to decode response body, %w", err), 1575 Snapshot: snapshot.Bytes(), 1576 } 1577 return err 1578 } 1579 1580 errorBody.Seek(0, io.SeekStart) 1581 if len(code) != 0 { 1582 errorCode = restjson.SanitizeErrorCode(code) 1583 } 1584 if len(message) != 0 { 1585 errorMessage = message 1586 } 1587 1588 switch { 1589 case strings.EqualFold("AccessDeniedException", errorCode): 1590 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1591 1592 case strings.EqualFold("ConflictException", errorCode): 1593 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1594 1595 case strings.EqualFold("InternalServerException", errorCode): 1596 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1597 1598 case strings.EqualFold("ResourceNotFoundException", errorCode): 1599 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1600 1601 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1602 return awsRestjson1_deserializeErrorServiceQuotaExceededException(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 1620type awsRestjson1_deserializeOpDeleteInvitations struct { 1621} 1622 1623func (*awsRestjson1_deserializeOpDeleteInvitations) ID() string { 1624 return "OperationDeserializer" 1625} 1626 1627func (m *awsRestjson1_deserializeOpDeleteInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1628 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1629) { 1630 out, metadata, err = next.HandleDeserialize(ctx, in) 1631 if err != nil { 1632 return out, metadata, err 1633 } 1634 1635 response, ok := out.RawResponse.(*smithyhttp.Response) 1636 if !ok { 1637 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1638 } 1639 1640 if response.StatusCode < 200 || response.StatusCode >= 300 { 1641 return out, metadata, awsRestjson1_deserializeOpErrorDeleteInvitations(response, &metadata) 1642 } 1643 output := &DeleteInvitationsOutput{} 1644 out.Result = output 1645 1646 var buff [1024]byte 1647 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1648 1649 body := io.TeeReader(response.Body, ringBuffer) 1650 1651 decoder := json.NewDecoder(body) 1652 decoder.UseNumber() 1653 var shape interface{} 1654 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1655 var snapshot bytes.Buffer 1656 io.Copy(&snapshot, ringBuffer) 1657 err = &smithy.DeserializationError{ 1658 Err: fmt.Errorf("failed to decode response body, %w", err), 1659 Snapshot: snapshot.Bytes(), 1660 } 1661 return out, metadata, err 1662 } 1663 1664 err = awsRestjson1_deserializeOpDocumentDeleteInvitationsOutput(&output, shape) 1665 if err != nil { 1666 var snapshot bytes.Buffer 1667 io.Copy(&snapshot, ringBuffer) 1668 return out, metadata, &smithy.DeserializationError{ 1669 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1670 Snapshot: snapshot.Bytes(), 1671 } 1672 } 1673 1674 return out, metadata, err 1675} 1676 1677func awsRestjson1_deserializeOpErrorDeleteInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1678 var errorBuffer bytes.Buffer 1679 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1680 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1681 } 1682 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1683 1684 errorCode := "UnknownError" 1685 errorMessage := errorCode 1686 1687 code := response.Header.Get("X-Amzn-ErrorType") 1688 if len(code) != 0 { 1689 errorCode = restjson.SanitizeErrorCode(code) 1690 } 1691 1692 var buff [1024]byte 1693 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1694 1695 body := io.TeeReader(errorBody, ringBuffer) 1696 decoder := json.NewDecoder(body) 1697 decoder.UseNumber() 1698 code, message, err := restjson.GetErrorInfo(decoder) 1699 if err != nil { 1700 var snapshot bytes.Buffer 1701 io.Copy(&snapshot, ringBuffer) 1702 err = &smithy.DeserializationError{ 1703 Err: fmt.Errorf("failed to decode response body, %w", err), 1704 Snapshot: snapshot.Bytes(), 1705 } 1706 return err 1707 } 1708 1709 errorBody.Seek(0, io.SeekStart) 1710 if len(code) != 0 { 1711 errorCode = restjson.SanitizeErrorCode(code) 1712 } 1713 if len(message) != 0 { 1714 errorMessage = message 1715 } 1716 1717 switch { 1718 case strings.EqualFold("AccessDeniedException", errorCode): 1719 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1720 1721 case strings.EqualFold("ConflictException", errorCode): 1722 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1723 1724 case strings.EqualFold("InternalServerException", errorCode): 1725 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1726 1727 case strings.EqualFold("ResourceNotFoundException", errorCode): 1728 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1729 1730 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1731 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 1732 1733 case strings.EqualFold("ThrottlingException", errorCode): 1734 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1735 1736 case strings.EqualFold("ValidationException", errorCode): 1737 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1738 1739 default: 1740 genericError := &smithy.GenericAPIError{ 1741 Code: errorCode, 1742 Message: errorMessage, 1743 } 1744 return genericError 1745 1746 } 1747} 1748 1749func awsRestjson1_deserializeOpDocumentDeleteInvitationsOutput(v **DeleteInvitationsOutput, value interface{}) error { 1750 if v == nil { 1751 return fmt.Errorf("unexpected nil of type %T", v) 1752 } 1753 if value == nil { 1754 return nil 1755 } 1756 1757 shape, ok := value.(map[string]interface{}) 1758 if !ok { 1759 return fmt.Errorf("unexpected JSON type %v", value) 1760 } 1761 1762 var sv *DeleteInvitationsOutput 1763 if *v == nil { 1764 sv = &DeleteInvitationsOutput{} 1765 } else { 1766 sv = *v 1767 } 1768 1769 for key, value := range shape { 1770 switch key { 1771 case "unprocessedAccounts": 1772 if err := awsRestjson1_deserializeDocument__listOfUnprocessedAccount(&sv.UnprocessedAccounts, value); err != nil { 1773 return err 1774 } 1775 1776 default: 1777 _, _ = key, value 1778 1779 } 1780 } 1781 *v = sv 1782 return nil 1783} 1784 1785type awsRestjson1_deserializeOpDeleteMember struct { 1786} 1787 1788func (*awsRestjson1_deserializeOpDeleteMember) ID() string { 1789 return "OperationDeserializer" 1790} 1791 1792func (m *awsRestjson1_deserializeOpDeleteMember) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1793 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1794) { 1795 out, metadata, err = next.HandleDeserialize(ctx, in) 1796 if err != nil { 1797 return out, metadata, err 1798 } 1799 1800 response, ok := out.RawResponse.(*smithyhttp.Response) 1801 if !ok { 1802 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1803 } 1804 1805 if response.StatusCode < 200 || response.StatusCode >= 300 { 1806 return out, metadata, awsRestjson1_deserializeOpErrorDeleteMember(response, &metadata) 1807 } 1808 output := &DeleteMemberOutput{} 1809 out.Result = output 1810 1811 return out, metadata, err 1812} 1813 1814func awsRestjson1_deserializeOpErrorDeleteMember(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1815 var errorBuffer bytes.Buffer 1816 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1817 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1818 } 1819 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1820 1821 errorCode := "UnknownError" 1822 errorMessage := errorCode 1823 1824 code := response.Header.Get("X-Amzn-ErrorType") 1825 if len(code) != 0 { 1826 errorCode = restjson.SanitizeErrorCode(code) 1827 } 1828 1829 var buff [1024]byte 1830 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1831 1832 body := io.TeeReader(errorBody, ringBuffer) 1833 decoder := json.NewDecoder(body) 1834 decoder.UseNumber() 1835 code, message, err := restjson.GetErrorInfo(decoder) 1836 if err != nil { 1837 var snapshot bytes.Buffer 1838 io.Copy(&snapshot, ringBuffer) 1839 err = &smithy.DeserializationError{ 1840 Err: fmt.Errorf("failed to decode response body, %w", err), 1841 Snapshot: snapshot.Bytes(), 1842 } 1843 return err 1844 } 1845 1846 errorBody.Seek(0, io.SeekStart) 1847 if len(code) != 0 { 1848 errorCode = restjson.SanitizeErrorCode(code) 1849 } 1850 if len(message) != 0 { 1851 errorMessage = message 1852 } 1853 1854 switch { 1855 case strings.EqualFold("AccessDeniedException", errorCode): 1856 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1857 1858 case strings.EqualFold("ConflictException", errorCode): 1859 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1860 1861 case strings.EqualFold("InternalServerException", errorCode): 1862 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1863 1864 case strings.EqualFold("ResourceNotFoundException", errorCode): 1865 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1866 1867 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1868 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 1869 1870 case strings.EqualFold("ThrottlingException", errorCode): 1871 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1872 1873 case strings.EqualFold("ValidationException", errorCode): 1874 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1875 1876 default: 1877 genericError := &smithy.GenericAPIError{ 1878 Code: errorCode, 1879 Message: errorMessage, 1880 } 1881 return genericError 1882 1883 } 1884} 1885 1886type awsRestjson1_deserializeOpDescribeBuckets struct { 1887} 1888 1889func (*awsRestjson1_deserializeOpDescribeBuckets) ID() string { 1890 return "OperationDeserializer" 1891} 1892 1893func (m *awsRestjson1_deserializeOpDescribeBuckets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1894 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1895) { 1896 out, metadata, err = next.HandleDeserialize(ctx, in) 1897 if err != nil { 1898 return out, metadata, err 1899 } 1900 1901 response, ok := out.RawResponse.(*smithyhttp.Response) 1902 if !ok { 1903 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1904 } 1905 1906 if response.StatusCode < 200 || response.StatusCode >= 300 { 1907 return out, metadata, awsRestjson1_deserializeOpErrorDescribeBuckets(response, &metadata) 1908 } 1909 output := &DescribeBucketsOutput{} 1910 out.Result = output 1911 1912 var buff [1024]byte 1913 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1914 1915 body := io.TeeReader(response.Body, ringBuffer) 1916 1917 decoder := json.NewDecoder(body) 1918 decoder.UseNumber() 1919 var shape interface{} 1920 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1921 var snapshot bytes.Buffer 1922 io.Copy(&snapshot, ringBuffer) 1923 err = &smithy.DeserializationError{ 1924 Err: fmt.Errorf("failed to decode response body, %w", err), 1925 Snapshot: snapshot.Bytes(), 1926 } 1927 return out, metadata, err 1928 } 1929 1930 err = awsRestjson1_deserializeOpDocumentDescribeBucketsOutput(&output, shape) 1931 if err != nil { 1932 var snapshot bytes.Buffer 1933 io.Copy(&snapshot, ringBuffer) 1934 return out, metadata, &smithy.DeserializationError{ 1935 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1936 Snapshot: snapshot.Bytes(), 1937 } 1938 } 1939 1940 return out, metadata, err 1941} 1942 1943func awsRestjson1_deserializeOpErrorDescribeBuckets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1944 var errorBuffer bytes.Buffer 1945 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1946 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1947 } 1948 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1949 1950 errorCode := "UnknownError" 1951 errorMessage := errorCode 1952 1953 code := response.Header.Get("X-Amzn-ErrorType") 1954 if len(code) != 0 { 1955 errorCode = restjson.SanitizeErrorCode(code) 1956 } 1957 1958 var buff [1024]byte 1959 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1960 1961 body := io.TeeReader(errorBody, ringBuffer) 1962 decoder := json.NewDecoder(body) 1963 decoder.UseNumber() 1964 code, message, err := restjson.GetErrorInfo(decoder) 1965 if err != nil { 1966 var snapshot bytes.Buffer 1967 io.Copy(&snapshot, ringBuffer) 1968 err = &smithy.DeserializationError{ 1969 Err: fmt.Errorf("failed to decode response body, %w", err), 1970 Snapshot: snapshot.Bytes(), 1971 } 1972 return err 1973 } 1974 1975 errorBody.Seek(0, io.SeekStart) 1976 if len(code) != 0 { 1977 errorCode = restjson.SanitizeErrorCode(code) 1978 } 1979 if len(message) != 0 { 1980 errorMessage = message 1981 } 1982 1983 switch { 1984 case strings.EqualFold("AccessDeniedException", errorCode): 1985 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1986 1987 case strings.EqualFold("ConflictException", errorCode): 1988 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1989 1990 case strings.EqualFold("InternalServerException", errorCode): 1991 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1992 1993 case strings.EqualFold("ResourceNotFoundException", errorCode): 1994 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1995 1996 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 1997 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 1998 1999 case strings.EqualFold("ThrottlingException", errorCode): 2000 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2001 2002 case strings.EqualFold("ValidationException", errorCode): 2003 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2004 2005 default: 2006 genericError := &smithy.GenericAPIError{ 2007 Code: errorCode, 2008 Message: errorMessage, 2009 } 2010 return genericError 2011 2012 } 2013} 2014 2015func awsRestjson1_deserializeOpDocumentDescribeBucketsOutput(v **DescribeBucketsOutput, value interface{}) error { 2016 if v == nil { 2017 return fmt.Errorf("unexpected nil of type %T", v) 2018 } 2019 if value == nil { 2020 return nil 2021 } 2022 2023 shape, ok := value.(map[string]interface{}) 2024 if !ok { 2025 return fmt.Errorf("unexpected JSON type %v", value) 2026 } 2027 2028 var sv *DescribeBucketsOutput 2029 if *v == nil { 2030 sv = &DescribeBucketsOutput{} 2031 } else { 2032 sv = *v 2033 } 2034 2035 for key, value := range shape { 2036 switch key { 2037 case "buckets": 2038 if err := awsRestjson1_deserializeDocument__listOfBucketMetadata(&sv.Buckets, value); err != nil { 2039 return err 2040 } 2041 2042 case "nextToken": 2043 if value != nil { 2044 jtv, ok := value.(string) 2045 if !ok { 2046 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2047 } 2048 sv.NextToken = ptr.String(jtv) 2049 } 2050 2051 default: 2052 _, _ = key, value 2053 2054 } 2055 } 2056 *v = sv 2057 return nil 2058} 2059 2060type awsRestjson1_deserializeOpDescribeClassificationJob struct { 2061} 2062 2063func (*awsRestjson1_deserializeOpDescribeClassificationJob) ID() string { 2064 return "OperationDeserializer" 2065} 2066 2067func (m *awsRestjson1_deserializeOpDescribeClassificationJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2068 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2069) { 2070 out, metadata, err = next.HandleDeserialize(ctx, in) 2071 if err != nil { 2072 return out, metadata, err 2073 } 2074 2075 response, ok := out.RawResponse.(*smithyhttp.Response) 2076 if !ok { 2077 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2078 } 2079 2080 if response.StatusCode < 200 || response.StatusCode >= 300 { 2081 return out, metadata, awsRestjson1_deserializeOpErrorDescribeClassificationJob(response, &metadata) 2082 } 2083 output := &DescribeClassificationJobOutput{} 2084 out.Result = output 2085 2086 var buff [1024]byte 2087 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2088 2089 body := io.TeeReader(response.Body, ringBuffer) 2090 2091 decoder := json.NewDecoder(body) 2092 decoder.UseNumber() 2093 var shape interface{} 2094 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2095 var snapshot bytes.Buffer 2096 io.Copy(&snapshot, ringBuffer) 2097 err = &smithy.DeserializationError{ 2098 Err: fmt.Errorf("failed to decode response body, %w", err), 2099 Snapshot: snapshot.Bytes(), 2100 } 2101 return out, metadata, err 2102 } 2103 2104 err = awsRestjson1_deserializeOpDocumentDescribeClassificationJobOutput(&output, shape) 2105 if err != nil { 2106 var snapshot bytes.Buffer 2107 io.Copy(&snapshot, ringBuffer) 2108 return out, metadata, &smithy.DeserializationError{ 2109 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2110 Snapshot: snapshot.Bytes(), 2111 } 2112 } 2113 2114 return out, metadata, err 2115} 2116 2117func awsRestjson1_deserializeOpErrorDescribeClassificationJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2118 var errorBuffer bytes.Buffer 2119 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2120 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2121 } 2122 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2123 2124 errorCode := "UnknownError" 2125 errorMessage := errorCode 2126 2127 code := response.Header.Get("X-Amzn-ErrorType") 2128 if len(code) != 0 { 2129 errorCode = restjson.SanitizeErrorCode(code) 2130 } 2131 2132 var buff [1024]byte 2133 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2134 2135 body := io.TeeReader(errorBody, ringBuffer) 2136 decoder := json.NewDecoder(body) 2137 decoder.UseNumber() 2138 code, message, err := restjson.GetErrorInfo(decoder) 2139 if err != nil { 2140 var snapshot bytes.Buffer 2141 io.Copy(&snapshot, ringBuffer) 2142 err = &smithy.DeserializationError{ 2143 Err: fmt.Errorf("failed to decode response body, %w", err), 2144 Snapshot: snapshot.Bytes(), 2145 } 2146 return err 2147 } 2148 2149 errorBody.Seek(0, io.SeekStart) 2150 if len(code) != 0 { 2151 errorCode = restjson.SanitizeErrorCode(code) 2152 } 2153 if len(message) != 0 { 2154 errorMessage = message 2155 } 2156 2157 switch { 2158 case strings.EqualFold("AccessDeniedException", errorCode): 2159 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2160 2161 case strings.EqualFold("ConflictException", errorCode): 2162 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2163 2164 case strings.EqualFold("InternalServerException", errorCode): 2165 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2166 2167 case strings.EqualFold("ResourceNotFoundException", errorCode): 2168 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2169 2170 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 2171 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 2172 2173 case strings.EqualFold("ThrottlingException", errorCode): 2174 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2175 2176 case strings.EqualFold("ValidationException", errorCode): 2177 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2178 2179 default: 2180 genericError := &smithy.GenericAPIError{ 2181 Code: errorCode, 2182 Message: errorMessage, 2183 } 2184 return genericError 2185 2186 } 2187} 2188 2189func awsRestjson1_deserializeOpDocumentDescribeClassificationJobOutput(v **DescribeClassificationJobOutput, value interface{}) error { 2190 if v == nil { 2191 return fmt.Errorf("unexpected nil of type %T", v) 2192 } 2193 if value == nil { 2194 return nil 2195 } 2196 2197 shape, ok := value.(map[string]interface{}) 2198 if !ok { 2199 return fmt.Errorf("unexpected JSON type %v", value) 2200 } 2201 2202 var sv *DescribeClassificationJobOutput 2203 if *v == nil { 2204 sv = &DescribeClassificationJobOutput{} 2205 } else { 2206 sv = *v 2207 } 2208 2209 for key, value := range shape { 2210 switch key { 2211 case "clientToken": 2212 if value != nil { 2213 jtv, ok := value.(string) 2214 if !ok { 2215 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2216 } 2217 sv.ClientToken = ptr.String(jtv) 2218 } 2219 2220 case "createdAt": 2221 if value != nil { 2222 jtv, ok := value.(string) 2223 if !ok { 2224 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 2225 } 2226 t, err := smithytime.ParseDateTime(jtv) 2227 if err != nil { 2228 return err 2229 } 2230 sv.CreatedAt = ptr.Time(t) 2231 } 2232 2233 case "customDataIdentifierIds": 2234 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.CustomDataIdentifierIds, value); err != nil { 2235 return err 2236 } 2237 2238 case "description": 2239 if value != nil { 2240 jtv, ok := value.(string) 2241 if !ok { 2242 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2243 } 2244 sv.Description = ptr.String(jtv) 2245 } 2246 2247 case "initialRun": 2248 if value != nil { 2249 jtv, ok := value.(bool) 2250 if !ok { 2251 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 2252 } 2253 sv.InitialRun = jtv 2254 } 2255 2256 case "jobArn": 2257 if value != nil { 2258 jtv, ok := value.(string) 2259 if !ok { 2260 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2261 } 2262 sv.JobArn = ptr.String(jtv) 2263 } 2264 2265 case "jobId": 2266 if value != nil { 2267 jtv, ok := value.(string) 2268 if !ok { 2269 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2270 } 2271 sv.JobId = ptr.String(jtv) 2272 } 2273 2274 case "jobStatus": 2275 if value != nil { 2276 jtv, ok := value.(string) 2277 if !ok { 2278 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 2279 } 2280 sv.JobStatus = types.JobStatus(jtv) 2281 } 2282 2283 case "jobType": 2284 if value != nil { 2285 jtv, ok := value.(string) 2286 if !ok { 2287 return fmt.Errorf("expected JobType to be of type string, got %T instead", value) 2288 } 2289 sv.JobType = types.JobType(jtv) 2290 } 2291 2292 case "lastRunErrorStatus": 2293 if err := awsRestjson1_deserializeDocumentLastRunErrorStatus(&sv.LastRunErrorStatus, value); err != nil { 2294 return err 2295 } 2296 2297 case "lastRunTime": 2298 if value != nil { 2299 jtv, ok := value.(string) 2300 if !ok { 2301 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 2302 } 2303 t, err := smithytime.ParseDateTime(jtv) 2304 if err != nil { 2305 return err 2306 } 2307 sv.LastRunTime = ptr.Time(t) 2308 } 2309 2310 case "name": 2311 if value != nil { 2312 jtv, ok := value.(string) 2313 if !ok { 2314 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2315 } 2316 sv.Name = ptr.String(jtv) 2317 } 2318 2319 case "s3JobDefinition": 2320 if err := awsRestjson1_deserializeDocumentS3JobDefinition(&sv.S3JobDefinition, value); err != nil { 2321 return err 2322 } 2323 2324 case "samplingPercentage": 2325 if value != nil { 2326 jtv, ok := value.(json.Number) 2327 if !ok { 2328 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 2329 } 2330 i64, err := jtv.Int64() 2331 if err != nil { 2332 return err 2333 } 2334 sv.SamplingPercentage = int32(i64) 2335 } 2336 2337 case "scheduleFrequency": 2338 if err := awsRestjson1_deserializeDocumentJobScheduleFrequency(&sv.ScheduleFrequency, value); err != nil { 2339 return err 2340 } 2341 2342 case "statistics": 2343 if err := awsRestjson1_deserializeDocumentStatistics(&sv.Statistics, value); err != nil { 2344 return err 2345 } 2346 2347 case "tags": 2348 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 2349 return err 2350 } 2351 2352 case "userPausedDetails": 2353 if err := awsRestjson1_deserializeDocumentUserPausedDetails(&sv.UserPausedDetails, value); err != nil { 2354 return err 2355 } 2356 2357 default: 2358 _, _ = key, value 2359 2360 } 2361 } 2362 *v = sv 2363 return nil 2364} 2365 2366type awsRestjson1_deserializeOpDescribeOrganizationConfiguration struct { 2367} 2368 2369func (*awsRestjson1_deserializeOpDescribeOrganizationConfiguration) ID() string { 2370 return "OperationDeserializer" 2371} 2372 2373func (m *awsRestjson1_deserializeOpDescribeOrganizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2374 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2375) { 2376 out, metadata, err = next.HandleDeserialize(ctx, in) 2377 if err != nil { 2378 return out, metadata, err 2379 } 2380 2381 response, ok := out.RawResponse.(*smithyhttp.Response) 2382 if !ok { 2383 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2384 } 2385 2386 if response.StatusCode < 200 || response.StatusCode >= 300 { 2387 return out, metadata, awsRestjson1_deserializeOpErrorDescribeOrganizationConfiguration(response, &metadata) 2388 } 2389 output := &DescribeOrganizationConfigurationOutput{} 2390 out.Result = output 2391 2392 var buff [1024]byte 2393 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2394 2395 body := io.TeeReader(response.Body, ringBuffer) 2396 2397 decoder := json.NewDecoder(body) 2398 decoder.UseNumber() 2399 var shape interface{} 2400 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2401 var snapshot bytes.Buffer 2402 io.Copy(&snapshot, ringBuffer) 2403 err = &smithy.DeserializationError{ 2404 Err: fmt.Errorf("failed to decode response body, %w", err), 2405 Snapshot: snapshot.Bytes(), 2406 } 2407 return out, metadata, err 2408 } 2409 2410 err = awsRestjson1_deserializeOpDocumentDescribeOrganizationConfigurationOutput(&output, shape) 2411 if err != nil { 2412 var snapshot bytes.Buffer 2413 io.Copy(&snapshot, ringBuffer) 2414 return out, metadata, &smithy.DeserializationError{ 2415 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2416 Snapshot: snapshot.Bytes(), 2417 } 2418 } 2419 2420 return out, metadata, err 2421} 2422 2423func awsRestjson1_deserializeOpErrorDescribeOrganizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2424 var errorBuffer bytes.Buffer 2425 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2426 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2427 } 2428 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2429 2430 errorCode := "UnknownError" 2431 errorMessage := errorCode 2432 2433 code := response.Header.Get("X-Amzn-ErrorType") 2434 if len(code) != 0 { 2435 errorCode = restjson.SanitizeErrorCode(code) 2436 } 2437 2438 var buff [1024]byte 2439 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2440 2441 body := io.TeeReader(errorBody, ringBuffer) 2442 decoder := json.NewDecoder(body) 2443 decoder.UseNumber() 2444 code, message, err := restjson.GetErrorInfo(decoder) 2445 if err != nil { 2446 var snapshot bytes.Buffer 2447 io.Copy(&snapshot, ringBuffer) 2448 err = &smithy.DeserializationError{ 2449 Err: fmt.Errorf("failed to decode response body, %w", err), 2450 Snapshot: snapshot.Bytes(), 2451 } 2452 return err 2453 } 2454 2455 errorBody.Seek(0, io.SeekStart) 2456 if len(code) != 0 { 2457 errorCode = restjson.SanitizeErrorCode(code) 2458 } 2459 if len(message) != 0 { 2460 errorMessage = message 2461 } 2462 2463 switch { 2464 case strings.EqualFold("AccessDeniedException", errorCode): 2465 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2466 2467 case strings.EqualFold("ConflictException", errorCode): 2468 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2469 2470 case strings.EqualFold("InternalServerException", errorCode): 2471 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2472 2473 case strings.EqualFold("ResourceNotFoundException", errorCode): 2474 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2475 2476 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 2477 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 2478 2479 case strings.EqualFold("ThrottlingException", errorCode): 2480 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2481 2482 case strings.EqualFold("ValidationException", errorCode): 2483 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2484 2485 default: 2486 genericError := &smithy.GenericAPIError{ 2487 Code: errorCode, 2488 Message: errorMessage, 2489 } 2490 return genericError 2491 2492 } 2493} 2494 2495func awsRestjson1_deserializeOpDocumentDescribeOrganizationConfigurationOutput(v **DescribeOrganizationConfigurationOutput, value interface{}) error { 2496 if v == nil { 2497 return fmt.Errorf("unexpected nil of type %T", v) 2498 } 2499 if value == nil { 2500 return nil 2501 } 2502 2503 shape, ok := value.(map[string]interface{}) 2504 if !ok { 2505 return fmt.Errorf("unexpected JSON type %v", value) 2506 } 2507 2508 var sv *DescribeOrganizationConfigurationOutput 2509 if *v == nil { 2510 sv = &DescribeOrganizationConfigurationOutput{} 2511 } else { 2512 sv = *v 2513 } 2514 2515 for key, value := range shape { 2516 switch key { 2517 case "autoEnable": 2518 if value != nil { 2519 jtv, ok := value.(bool) 2520 if !ok { 2521 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 2522 } 2523 sv.AutoEnable = jtv 2524 } 2525 2526 case "maxAccountLimitReached": 2527 if value != nil { 2528 jtv, ok := value.(bool) 2529 if !ok { 2530 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 2531 } 2532 sv.MaxAccountLimitReached = jtv 2533 } 2534 2535 default: 2536 _, _ = key, value 2537 2538 } 2539 } 2540 *v = sv 2541 return nil 2542} 2543 2544type awsRestjson1_deserializeOpDisableMacie struct { 2545} 2546 2547func (*awsRestjson1_deserializeOpDisableMacie) ID() string { 2548 return "OperationDeserializer" 2549} 2550 2551func (m *awsRestjson1_deserializeOpDisableMacie) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2552 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2553) { 2554 out, metadata, err = next.HandleDeserialize(ctx, in) 2555 if err != nil { 2556 return out, metadata, err 2557 } 2558 2559 response, ok := out.RawResponse.(*smithyhttp.Response) 2560 if !ok { 2561 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2562 } 2563 2564 if response.StatusCode < 200 || response.StatusCode >= 300 { 2565 return out, metadata, awsRestjson1_deserializeOpErrorDisableMacie(response, &metadata) 2566 } 2567 output := &DisableMacieOutput{} 2568 out.Result = output 2569 2570 return out, metadata, err 2571} 2572 2573func awsRestjson1_deserializeOpErrorDisableMacie(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2574 var errorBuffer bytes.Buffer 2575 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2576 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2577 } 2578 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2579 2580 errorCode := "UnknownError" 2581 errorMessage := errorCode 2582 2583 code := response.Header.Get("X-Amzn-ErrorType") 2584 if len(code) != 0 { 2585 errorCode = restjson.SanitizeErrorCode(code) 2586 } 2587 2588 var buff [1024]byte 2589 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2590 2591 body := io.TeeReader(errorBody, ringBuffer) 2592 decoder := json.NewDecoder(body) 2593 decoder.UseNumber() 2594 code, message, err := restjson.GetErrorInfo(decoder) 2595 if err != nil { 2596 var snapshot bytes.Buffer 2597 io.Copy(&snapshot, ringBuffer) 2598 err = &smithy.DeserializationError{ 2599 Err: fmt.Errorf("failed to decode response body, %w", err), 2600 Snapshot: snapshot.Bytes(), 2601 } 2602 return err 2603 } 2604 2605 errorBody.Seek(0, io.SeekStart) 2606 if len(code) != 0 { 2607 errorCode = restjson.SanitizeErrorCode(code) 2608 } 2609 if len(message) != 0 { 2610 errorMessage = message 2611 } 2612 2613 switch { 2614 case strings.EqualFold("AccessDeniedException", errorCode): 2615 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2616 2617 case strings.EqualFold("ConflictException", errorCode): 2618 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2619 2620 case strings.EqualFold("InternalServerException", errorCode): 2621 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2622 2623 case strings.EqualFold("ResourceNotFoundException", errorCode): 2624 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2625 2626 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 2627 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 2628 2629 case strings.EqualFold("ThrottlingException", errorCode): 2630 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2631 2632 case strings.EqualFold("ValidationException", errorCode): 2633 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2634 2635 default: 2636 genericError := &smithy.GenericAPIError{ 2637 Code: errorCode, 2638 Message: errorMessage, 2639 } 2640 return genericError 2641 2642 } 2643} 2644 2645type awsRestjson1_deserializeOpDisableOrganizationAdminAccount struct { 2646} 2647 2648func (*awsRestjson1_deserializeOpDisableOrganizationAdminAccount) ID() string { 2649 return "OperationDeserializer" 2650} 2651 2652func (m *awsRestjson1_deserializeOpDisableOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2653 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2654) { 2655 out, metadata, err = next.HandleDeserialize(ctx, in) 2656 if err != nil { 2657 return out, metadata, err 2658 } 2659 2660 response, ok := out.RawResponse.(*smithyhttp.Response) 2661 if !ok { 2662 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2663 } 2664 2665 if response.StatusCode < 200 || response.StatusCode >= 300 { 2666 return out, metadata, awsRestjson1_deserializeOpErrorDisableOrganizationAdminAccount(response, &metadata) 2667 } 2668 output := &DisableOrganizationAdminAccountOutput{} 2669 out.Result = output 2670 2671 return out, metadata, err 2672} 2673 2674func awsRestjson1_deserializeOpErrorDisableOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2675 var errorBuffer bytes.Buffer 2676 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2677 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2678 } 2679 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2680 2681 errorCode := "UnknownError" 2682 errorMessage := errorCode 2683 2684 code := response.Header.Get("X-Amzn-ErrorType") 2685 if len(code) != 0 { 2686 errorCode = restjson.SanitizeErrorCode(code) 2687 } 2688 2689 var buff [1024]byte 2690 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2691 2692 body := io.TeeReader(errorBody, ringBuffer) 2693 decoder := json.NewDecoder(body) 2694 decoder.UseNumber() 2695 code, message, err := restjson.GetErrorInfo(decoder) 2696 if err != nil { 2697 var snapshot bytes.Buffer 2698 io.Copy(&snapshot, ringBuffer) 2699 err = &smithy.DeserializationError{ 2700 Err: fmt.Errorf("failed to decode response body, %w", err), 2701 Snapshot: snapshot.Bytes(), 2702 } 2703 return err 2704 } 2705 2706 errorBody.Seek(0, io.SeekStart) 2707 if len(code) != 0 { 2708 errorCode = restjson.SanitizeErrorCode(code) 2709 } 2710 if len(message) != 0 { 2711 errorMessage = message 2712 } 2713 2714 switch { 2715 case strings.EqualFold("AccessDeniedException", errorCode): 2716 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2717 2718 case strings.EqualFold("ConflictException", errorCode): 2719 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2720 2721 case strings.EqualFold("InternalServerException", errorCode): 2722 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2723 2724 case strings.EqualFold("ResourceNotFoundException", errorCode): 2725 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2726 2727 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 2728 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 2729 2730 case strings.EqualFold("ThrottlingException", errorCode): 2731 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2732 2733 case strings.EqualFold("ValidationException", errorCode): 2734 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2735 2736 default: 2737 genericError := &smithy.GenericAPIError{ 2738 Code: errorCode, 2739 Message: errorMessage, 2740 } 2741 return genericError 2742 2743 } 2744} 2745 2746type awsRestjson1_deserializeOpDisassociateFromMasterAccount struct { 2747} 2748 2749func (*awsRestjson1_deserializeOpDisassociateFromMasterAccount) ID() string { 2750 return "OperationDeserializer" 2751} 2752 2753func (m *awsRestjson1_deserializeOpDisassociateFromMasterAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2754 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2755) { 2756 out, metadata, err = next.HandleDeserialize(ctx, in) 2757 if err != nil { 2758 return out, metadata, err 2759 } 2760 2761 response, ok := out.RawResponse.(*smithyhttp.Response) 2762 if !ok { 2763 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2764 } 2765 2766 if response.StatusCode < 200 || response.StatusCode >= 300 { 2767 return out, metadata, awsRestjson1_deserializeOpErrorDisassociateFromMasterAccount(response, &metadata) 2768 } 2769 output := &DisassociateFromMasterAccountOutput{} 2770 out.Result = output 2771 2772 return out, metadata, err 2773} 2774 2775func awsRestjson1_deserializeOpErrorDisassociateFromMasterAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2776 var errorBuffer bytes.Buffer 2777 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2778 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2779 } 2780 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2781 2782 errorCode := "UnknownError" 2783 errorMessage := errorCode 2784 2785 code := response.Header.Get("X-Amzn-ErrorType") 2786 if len(code) != 0 { 2787 errorCode = restjson.SanitizeErrorCode(code) 2788 } 2789 2790 var buff [1024]byte 2791 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2792 2793 body := io.TeeReader(errorBody, ringBuffer) 2794 decoder := json.NewDecoder(body) 2795 decoder.UseNumber() 2796 code, message, err := restjson.GetErrorInfo(decoder) 2797 if err != nil { 2798 var snapshot bytes.Buffer 2799 io.Copy(&snapshot, ringBuffer) 2800 err = &smithy.DeserializationError{ 2801 Err: fmt.Errorf("failed to decode response body, %w", err), 2802 Snapshot: snapshot.Bytes(), 2803 } 2804 return err 2805 } 2806 2807 errorBody.Seek(0, io.SeekStart) 2808 if len(code) != 0 { 2809 errorCode = restjson.SanitizeErrorCode(code) 2810 } 2811 if len(message) != 0 { 2812 errorMessage = message 2813 } 2814 2815 switch { 2816 case strings.EqualFold("AccessDeniedException", errorCode): 2817 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2818 2819 case strings.EqualFold("ConflictException", errorCode): 2820 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2821 2822 case strings.EqualFold("InternalServerException", errorCode): 2823 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2824 2825 case strings.EqualFold("ResourceNotFoundException", errorCode): 2826 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2827 2828 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 2829 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 2830 2831 case strings.EqualFold("ThrottlingException", errorCode): 2832 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2833 2834 case strings.EqualFold("ValidationException", errorCode): 2835 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2836 2837 default: 2838 genericError := &smithy.GenericAPIError{ 2839 Code: errorCode, 2840 Message: errorMessage, 2841 } 2842 return genericError 2843 2844 } 2845} 2846 2847type awsRestjson1_deserializeOpDisassociateMember struct { 2848} 2849 2850func (*awsRestjson1_deserializeOpDisassociateMember) ID() string { 2851 return "OperationDeserializer" 2852} 2853 2854func (m *awsRestjson1_deserializeOpDisassociateMember) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2855 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2856) { 2857 out, metadata, err = next.HandleDeserialize(ctx, in) 2858 if err != nil { 2859 return out, metadata, err 2860 } 2861 2862 response, ok := out.RawResponse.(*smithyhttp.Response) 2863 if !ok { 2864 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2865 } 2866 2867 if response.StatusCode < 200 || response.StatusCode >= 300 { 2868 return out, metadata, awsRestjson1_deserializeOpErrorDisassociateMember(response, &metadata) 2869 } 2870 output := &DisassociateMemberOutput{} 2871 out.Result = output 2872 2873 return out, metadata, err 2874} 2875 2876func awsRestjson1_deserializeOpErrorDisassociateMember(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2877 var errorBuffer bytes.Buffer 2878 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2879 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2880 } 2881 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2882 2883 errorCode := "UnknownError" 2884 errorMessage := errorCode 2885 2886 code := response.Header.Get("X-Amzn-ErrorType") 2887 if len(code) != 0 { 2888 errorCode = restjson.SanitizeErrorCode(code) 2889 } 2890 2891 var buff [1024]byte 2892 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2893 2894 body := io.TeeReader(errorBody, ringBuffer) 2895 decoder := json.NewDecoder(body) 2896 decoder.UseNumber() 2897 code, message, err := restjson.GetErrorInfo(decoder) 2898 if err != nil { 2899 var snapshot bytes.Buffer 2900 io.Copy(&snapshot, ringBuffer) 2901 err = &smithy.DeserializationError{ 2902 Err: fmt.Errorf("failed to decode response body, %w", err), 2903 Snapshot: snapshot.Bytes(), 2904 } 2905 return err 2906 } 2907 2908 errorBody.Seek(0, io.SeekStart) 2909 if len(code) != 0 { 2910 errorCode = restjson.SanitizeErrorCode(code) 2911 } 2912 if len(message) != 0 { 2913 errorMessage = message 2914 } 2915 2916 switch { 2917 case strings.EqualFold("AccessDeniedException", errorCode): 2918 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2919 2920 case strings.EqualFold("ConflictException", errorCode): 2921 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2922 2923 case strings.EqualFold("InternalServerException", errorCode): 2924 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2925 2926 case strings.EqualFold("ResourceNotFoundException", errorCode): 2927 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2928 2929 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 2930 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 2931 2932 case strings.EqualFold("ThrottlingException", errorCode): 2933 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2934 2935 case strings.EqualFold("ValidationException", errorCode): 2936 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2937 2938 default: 2939 genericError := &smithy.GenericAPIError{ 2940 Code: errorCode, 2941 Message: errorMessage, 2942 } 2943 return genericError 2944 2945 } 2946} 2947 2948type awsRestjson1_deserializeOpEnableMacie struct { 2949} 2950 2951func (*awsRestjson1_deserializeOpEnableMacie) ID() string { 2952 return "OperationDeserializer" 2953} 2954 2955func (m *awsRestjson1_deserializeOpEnableMacie) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2956 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2957) { 2958 out, metadata, err = next.HandleDeserialize(ctx, in) 2959 if err != nil { 2960 return out, metadata, err 2961 } 2962 2963 response, ok := out.RawResponse.(*smithyhttp.Response) 2964 if !ok { 2965 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2966 } 2967 2968 if response.StatusCode < 200 || response.StatusCode >= 300 { 2969 return out, metadata, awsRestjson1_deserializeOpErrorEnableMacie(response, &metadata) 2970 } 2971 output := &EnableMacieOutput{} 2972 out.Result = output 2973 2974 return out, metadata, err 2975} 2976 2977func awsRestjson1_deserializeOpErrorEnableMacie(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2978 var errorBuffer bytes.Buffer 2979 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2980 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2981 } 2982 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2983 2984 errorCode := "UnknownError" 2985 errorMessage := errorCode 2986 2987 code := response.Header.Get("X-Amzn-ErrorType") 2988 if len(code) != 0 { 2989 errorCode = restjson.SanitizeErrorCode(code) 2990 } 2991 2992 var buff [1024]byte 2993 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2994 2995 body := io.TeeReader(errorBody, ringBuffer) 2996 decoder := json.NewDecoder(body) 2997 decoder.UseNumber() 2998 code, message, err := restjson.GetErrorInfo(decoder) 2999 if err != nil { 3000 var snapshot bytes.Buffer 3001 io.Copy(&snapshot, ringBuffer) 3002 err = &smithy.DeserializationError{ 3003 Err: fmt.Errorf("failed to decode response body, %w", err), 3004 Snapshot: snapshot.Bytes(), 3005 } 3006 return err 3007 } 3008 3009 errorBody.Seek(0, io.SeekStart) 3010 if len(code) != 0 { 3011 errorCode = restjson.SanitizeErrorCode(code) 3012 } 3013 if len(message) != 0 { 3014 errorMessage = message 3015 } 3016 3017 switch { 3018 case strings.EqualFold("AccessDeniedException", errorCode): 3019 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3020 3021 case strings.EqualFold("ConflictException", errorCode): 3022 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3023 3024 case strings.EqualFold("InternalServerException", errorCode): 3025 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3026 3027 case strings.EqualFold("ResourceNotFoundException", errorCode): 3028 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3029 3030 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3031 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3032 3033 case strings.EqualFold("ThrottlingException", errorCode): 3034 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3035 3036 case strings.EqualFold("ValidationException", errorCode): 3037 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3038 3039 default: 3040 genericError := &smithy.GenericAPIError{ 3041 Code: errorCode, 3042 Message: errorMessage, 3043 } 3044 return genericError 3045 3046 } 3047} 3048 3049type awsRestjson1_deserializeOpEnableOrganizationAdminAccount struct { 3050} 3051 3052func (*awsRestjson1_deserializeOpEnableOrganizationAdminAccount) ID() string { 3053 return "OperationDeserializer" 3054} 3055 3056func (m *awsRestjson1_deserializeOpEnableOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3057 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3058) { 3059 out, metadata, err = next.HandleDeserialize(ctx, in) 3060 if err != nil { 3061 return out, metadata, err 3062 } 3063 3064 response, ok := out.RawResponse.(*smithyhttp.Response) 3065 if !ok { 3066 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3067 } 3068 3069 if response.StatusCode < 200 || response.StatusCode >= 300 { 3070 return out, metadata, awsRestjson1_deserializeOpErrorEnableOrganizationAdminAccount(response, &metadata) 3071 } 3072 output := &EnableOrganizationAdminAccountOutput{} 3073 out.Result = output 3074 3075 return out, metadata, err 3076} 3077 3078func awsRestjson1_deserializeOpErrorEnableOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3079 var errorBuffer bytes.Buffer 3080 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3081 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3082 } 3083 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3084 3085 errorCode := "UnknownError" 3086 errorMessage := errorCode 3087 3088 code := response.Header.Get("X-Amzn-ErrorType") 3089 if len(code) != 0 { 3090 errorCode = restjson.SanitizeErrorCode(code) 3091 } 3092 3093 var buff [1024]byte 3094 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3095 3096 body := io.TeeReader(errorBody, ringBuffer) 3097 decoder := json.NewDecoder(body) 3098 decoder.UseNumber() 3099 code, message, err := restjson.GetErrorInfo(decoder) 3100 if err != nil { 3101 var snapshot bytes.Buffer 3102 io.Copy(&snapshot, ringBuffer) 3103 err = &smithy.DeserializationError{ 3104 Err: fmt.Errorf("failed to decode response body, %w", err), 3105 Snapshot: snapshot.Bytes(), 3106 } 3107 return err 3108 } 3109 3110 errorBody.Seek(0, io.SeekStart) 3111 if len(code) != 0 { 3112 errorCode = restjson.SanitizeErrorCode(code) 3113 } 3114 if len(message) != 0 { 3115 errorMessage = message 3116 } 3117 3118 switch { 3119 case strings.EqualFold("AccessDeniedException", errorCode): 3120 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3121 3122 case strings.EqualFold("ConflictException", errorCode): 3123 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3124 3125 case strings.EqualFold("InternalServerException", errorCode): 3126 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3127 3128 case strings.EqualFold("ResourceNotFoundException", errorCode): 3129 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3130 3131 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3132 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3133 3134 case strings.EqualFold("ThrottlingException", errorCode): 3135 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3136 3137 case strings.EqualFold("ValidationException", errorCode): 3138 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3139 3140 default: 3141 genericError := &smithy.GenericAPIError{ 3142 Code: errorCode, 3143 Message: errorMessage, 3144 } 3145 return genericError 3146 3147 } 3148} 3149 3150type awsRestjson1_deserializeOpGetBucketStatistics struct { 3151} 3152 3153func (*awsRestjson1_deserializeOpGetBucketStatistics) ID() string { 3154 return "OperationDeserializer" 3155} 3156 3157func (m *awsRestjson1_deserializeOpGetBucketStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3158 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3159) { 3160 out, metadata, err = next.HandleDeserialize(ctx, in) 3161 if err != nil { 3162 return out, metadata, err 3163 } 3164 3165 response, ok := out.RawResponse.(*smithyhttp.Response) 3166 if !ok { 3167 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3168 } 3169 3170 if response.StatusCode < 200 || response.StatusCode >= 300 { 3171 return out, metadata, awsRestjson1_deserializeOpErrorGetBucketStatistics(response, &metadata) 3172 } 3173 output := &GetBucketStatisticsOutput{} 3174 out.Result = output 3175 3176 var buff [1024]byte 3177 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3178 3179 body := io.TeeReader(response.Body, ringBuffer) 3180 3181 decoder := json.NewDecoder(body) 3182 decoder.UseNumber() 3183 var shape interface{} 3184 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3185 var snapshot bytes.Buffer 3186 io.Copy(&snapshot, ringBuffer) 3187 err = &smithy.DeserializationError{ 3188 Err: fmt.Errorf("failed to decode response body, %w", err), 3189 Snapshot: snapshot.Bytes(), 3190 } 3191 return out, metadata, err 3192 } 3193 3194 err = awsRestjson1_deserializeOpDocumentGetBucketStatisticsOutput(&output, shape) 3195 if err != nil { 3196 var snapshot bytes.Buffer 3197 io.Copy(&snapshot, ringBuffer) 3198 return out, metadata, &smithy.DeserializationError{ 3199 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3200 Snapshot: snapshot.Bytes(), 3201 } 3202 } 3203 3204 return out, metadata, err 3205} 3206 3207func awsRestjson1_deserializeOpErrorGetBucketStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3208 var errorBuffer bytes.Buffer 3209 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3210 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3211 } 3212 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3213 3214 errorCode := "UnknownError" 3215 errorMessage := errorCode 3216 3217 code := response.Header.Get("X-Amzn-ErrorType") 3218 if len(code) != 0 { 3219 errorCode = restjson.SanitizeErrorCode(code) 3220 } 3221 3222 var buff [1024]byte 3223 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3224 3225 body := io.TeeReader(errorBody, ringBuffer) 3226 decoder := json.NewDecoder(body) 3227 decoder.UseNumber() 3228 code, message, err := restjson.GetErrorInfo(decoder) 3229 if err != nil { 3230 var snapshot bytes.Buffer 3231 io.Copy(&snapshot, ringBuffer) 3232 err = &smithy.DeserializationError{ 3233 Err: fmt.Errorf("failed to decode response body, %w", err), 3234 Snapshot: snapshot.Bytes(), 3235 } 3236 return err 3237 } 3238 3239 errorBody.Seek(0, io.SeekStart) 3240 if len(code) != 0 { 3241 errorCode = restjson.SanitizeErrorCode(code) 3242 } 3243 if len(message) != 0 { 3244 errorMessage = message 3245 } 3246 3247 switch { 3248 case strings.EqualFold("AccessDeniedException", errorCode): 3249 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3250 3251 case strings.EqualFold("ConflictException", errorCode): 3252 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3253 3254 case strings.EqualFold("InternalServerException", errorCode): 3255 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3256 3257 case strings.EqualFold("ResourceNotFoundException", errorCode): 3258 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3259 3260 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3261 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3262 3263 case strings.EqualFold("ThrottlingException", errorCode): 3264 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3265 3266 case strings.EqualFold("ValidationException", errorCode): 3267 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3268 3269 default: 3270 genericError := &smithy.GenericAPIError{ 3271 Code: errorCode, 3272 Message: errorMessage, 3273 } 3274 return genericError 3275 3276 } 3277} 3278 3279func awsRestjson1_deserializeOpDocumentGetBucketStatisticsOutput(v **GetBucketStatisticsOutput, value interface{}) error { 3280 if v == nil { 3281 return fmt.Errorf("unexpected nil of type %T", v) 3282 } 3283 if value == nil { 3284 return nil 3285 } 3286 3287 shape, ok := value.(map[string]interface{}) 3288 if !ok { 3289 return fmt.Errorf("unexpected JSON type %v", value) 3290 } 3291 3292 var sv *GetBucketStatisticsOutput 3293 if *v == nil { 3294 sv = &GetBucketStatisticsOutput{} 3295 } else { 3296 sv = *v 3297 } 3298 3299 for key, value := range shape { 3300 switch key { 3301 case "bucketCount": 3302 if value != nil { 3303 jtv, ok := value.(json.Number) 3304 if !ok { 3305 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3306 } 3307 i64, err := jtv.Int64() 3308 if err != nil { 3309 return err 3310 } 3311 sv.BucketCount = i64 3312 } 3313 3314 case "bucketCountByEffectivePermission": 3315 if err := awsRestjson1_deserializeDocumentBucketCountByEffectivePermission(&sv.BucketCountByEffectivePermission, value); err != nil { 3316 return err 3317 } 3318 3319 case "bucketCountByEncryptionType": 3320 if err := awsRestjson1_deserializeDocumentBucketCountByEncryptionType(&sv.BucketCountByEncryptionType, value); err != nil { 3321 return err 3322 } 3323 3324 case "bucketCountBySharedAccessType": 3325 if err := awsRestjson1_deserializeDocumentBucketCountBySharedAccessType(&sv.BucketCountBySharedAccessType, value); err != nil { 3326 return err 3327 } 3328 3329 case "classifiableObjectCount": 3330 if value != nil { 3331 jtv, ok := value.(json.Number) 3332 if !ok { 3333 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3334 } 3335 i64, err := jtv.Int64() 3336 if err != nil { 3337 return err 3338 } 3339 sv.ClassifiableObjectCount = i64 3340 } 3341 3342 case "classifiableSizeInBytes": 3343 if value != nil { 3344 jtv, ok := value.(json.Number) 3345 if !ok { 3346 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3347 } 3348 i64, err := jtv.Int64() 3349 if err != nil { 3350 return err 3351 } 3352 sv.ClassifiableSizeInBytes = i64 3353 } 3354 3355 case "lastUpdated": 3356 if value != nil { 3357 jtv, ok := value.(string) 3358 if !ok { 3359 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 3360 } 3361 t, err := smithytime.ParseDateTime(jtv) 3362 if err != nil { 3363 return err 3364 } 3365 sv.LastUpdated = ptr.Time(t) 3366 } 3367 3368 case "objectCount": 3369 if value != nil { 3370 jtv, ok := value.(json.Number) 3371 if !ok { 3372 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3373 } 3374 i64, err := jtv.Int64() 3375 if err != nil { 3376 return err 3377 } 3378 sv.ObjectCount = i64 3379 } 3380 3381 case "sizeInBytes": 3382 if value != nil { 3383 jtv, ok := value.(json.Number) 3384 if !ok { 3385 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3386 } 3387 i64, err := jtv.Int64() 3388 if err != nil { 3389 return err 3390 } 3391 sv.SizeInBytes = i64 3392 } 3393 3394 case "sizeInBytesCompressed": 3395 if value != nil { 3396 jtv, ok := value.(json.Number) 3397 if !ok { 3398 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3399 } 3400 i64, err := jtv.Int64() 3401 if err != nil { 3402 return err 3403 } 3404 sv.SizeInBytesCompressed = i64 3405 } 3406 3407 case "unclassifiableObjectCount": 3408 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectCount, value); err != nil { 3409 return err 3410 } 3411 3412 case "unclassifiableObjectSizeInBytes": 3413 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectSizeInBytes, value); err != nil { 3414 return err 3415 } 3416 3417 default: 3418 _, _ = key, value 3419 3420 } 3421 } 3422 *v = sv 3423 return nil 3424} 3425 3426type awsRestjson1_deserializeOpGetClassificationExportConfiguration struct { 3427} 3428 3429func (*awsRestjson1_deserializeOpGetClassificationExportConfiguration) ID() string { 3430 return "OperationDeserializer" 3431} 3432 3433func (m *awsRestjson1_deserializeOpGetClassificationExportConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3434 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3435) { 3436 out, metadata, err = next.HandleDeserialize(ctx, in) 3437 if err != nil { 3438 return out, metadata, err 3439 } 3440 3441 response, ok := out.RawResponse.(*smithyhttp.Response) 3442 if !ok { 3443 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3444 } 3445 3446 if response.StatusCode < 200 || response.StatusCode >= 300 { 3447 return out, metadata, awsRestjson1_deserializeOpErrorGetClassificationExportConfiguration(response, &metadata) 3448 } 3449 output := &GetClassificationExportConfigurationOutput{} 3450 out.Result = output 3451 3452 var buff [1024]byte 3453 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3454 3455 body := io.TeeReader(response.Body, ringBuffer) 3456 3457 decoder := json.NewDecoder(body) 3458 decoder.UseNumber() 3459 var shape interface{} 3460 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3461 var snapshot bytes.Buffer 3462 io.Copy(&snapshot, ringBuffer) 3463 err = &smithy.DeserializationError{ 3464 Err: fmt.Errorf("failed to decode response body, %w", err), 3465 Snapshot: snapshot.Bytes(), 3466 } 3467 return out, metadata, err 3468 } 3469 3470 err = awsRestjson1_deserializeOpDocumentGetClassificationExportConfigurationOutput(&output, shape) 3471 if err != nil { 3472 var snapshot bytes.Buffer 3473 io.Copy(&snapshot, ringBuffer) 3474 return out, metadata, &smithy.DeserializationError{ 3475 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3476 Snapshot: snapshot.Bytes(), 3477 } 3478 } 3479 3480 return out, metadata, err 3481} 3482 3483func awsRestjson1_deserializeOpErrorGetClassificationExportConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3484 var errorBuffer bytes.Buffer 3485 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3486 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3487 } 3488 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3489 3490 errorCode := "UnknownError" 3491 errorMessage := errorCode 3492 3493 code := response.Header.Get("X-Amzn-ErrorType") 3494 if len(code) != 0 { 3495 errorCode = restjson.SanitizeErrorCode(code) 3496 } 3497 3498 var buff [1024]byte 3499 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3500 3501 body := io.TeeReader(errorBody, ringBuffer) 3502 decoder := json.NewDecoder(body) 3503 decoder.UseNumber() 3504 code, message, err := restjson.GetErrorInfo(decoder) 3505 if err != nil { 3506 var snapshot bytes.Buffer 3507 io.Copy(&snapshot, ringBuffer) 3508 err = &smithy.DeserializationError{ 3509 Err: fmt.Errorf("failed to decode response body, %w", err), 3510 Snapshot: snapshot.Bytes(), 3511 } 3512 return err 3513 } 3514 3515 errorBody.Seek(0, io.SeekStart) 3516 if len(code) != 0 { 3517 errorCode = restjson.SanitizeErrorCode(code) 3518 } 3519 if len(message) != 0 { 3520 errorMessage = message 3521 } 3522 3523 switch { 3524 case strings.EqualFold("AccessDeniedException", errorCode): 3525 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3526 3527 case strings.EqualFold("ConflictException", errorCode): 3528 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3529 3530 case strings.EqualFold("InternalServerException", errorCode): 3531 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3532 3533 case strings.EqualFold("ResourceNotFoundException", errorCode): 3534 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3535 3536 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3537 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3538 3539 case strings.EqualFold("ThrottlingException", errorCode): 3540 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3541 3542 case strings.EqualFold("ValidationException", errorCode): 3543 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3544 3545 default: 3546 genericError := &smithy.GenericAPIError{ 3547 Code: errorCode, 3548 Message: errorMessage, 3549 } 3550 return genericError 3551 3552 } 3553} 3554 3555func awsRestjson1_deserializeOpDocumentGetClassificationExportConfigurationOutput(v **GetClassificationExportConfigurationOutput, value interface{}) error { 3556 if v == nil { 3557 return fmt.Errorf("unexpected nil of type %T", v) 3558 } 3559 if value == nil { 3560 return nil 3561 } 3562 3563 shape, ok := value.(map[string]interface{}) 3564 if !ok { 3565 return fmt.Errorf("unexpected JSON type %v", value) 3566 } 3567 3568 var sv *GetClassificationExportConfigurationOutput 3569 if *v == nil { 3570 sv = &GetClassificationExportConfigurationOutput{} 3571 } else { 3572 sv = *v 3573 } 3574 3575 for key, value := range shape { 3576 switch key { 3577 case "configuration": 3578 if err := awsRestjson1_deserializeDocumentClassificationExportConfiguration(&sv.Configuration, value); err != nil { 3579 return err 3580 } 3581 3582 default: 3583 _, _ = key, value 3584 3585 } 3586 } 3587 *v = sv 3588 return nil 3589} 3590 3591type awsRestjson1_deserializeOpGetCustomDataIdentifier struct { 3592} 3593 3594func (*awsRestjson1_deserializeOpGetCustomDataIdentifier) ID() string { 3595 return "OperationDeserializer" 3596} 3597 3598func (m *awsRestjson1_deserializeOpGetCustomDataIdentifier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3599 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3600) { 3601 out, metadata, err = next.HandleDeserialize(ctx, in) 3602 if err != nil { 3603 return out, metadata, err 3604 } 3605 3606 response, ok := out.RawResponse.(*smithyhttp.Response) 3607 if !ok { 3608 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3609 } 3610 3611 if response.StatusCode < 200 || response.StatusCode >= 300 { 3612 return out, metadata, awsRestjson1_deserializeOpErrorGetCustomDataIdentifier(response, &metadata) 3613 } 3614 output := &GetCustomDataIdentifierOutput{} 3615 out.Result = output 3616 3617 var buff [1024]byte 3618 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3619 3620 body := io.TeeReader(response.Body, ringBuffer) 3621 3622 decoder := json.NewDecoder(body) 3623 decoder.UseNumber() 3624 var shape interface{} 3625 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3626 var snapshot bytes.Buffer 3627 io.Copy(&snapshot, ringBuffer) 3628 err = &smithy.DeserializationError{ 3629 Err: fmt.Errorf("failed to decode response body, %w", err), 3630 Snapshot: snapshot.Bytes(), 3631 } 3632 return out, metadata, err 3633 } 3634 3635 err = awsRestjson1_deserializeOpDocumentGetCustomDataIdentifierOutput(&output, shape) 3636 if err != nil { 3637 var snapshot bytes.Buffer 3638 io.Copy(&snapshot, ringBuffer) 3639 return out, metadata, &smithy.DeserializationError{ 3640 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3641 Snapshot: snapshot.Bytes(), 3642 } 3643 } 3644 3645 return out, metadata, err 3646} 3647 3648func awsRestjson1_deserializeOpErrorGetCustomDataIdentifier(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3649 var errorBuffer bytes.Buffer 3650 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3651 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3652 } 3653 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3654 3655 errorCode := "UnknownError" 3656 errorMessage := errorCode 3657 3658 code := response.Header.Get("X-Amzn-ErrorType") 3659 if len(code) != 0 { 3660 errorCode = restjson.SanitizeErrorCode(code) 3661 } 3662 3663 var buff [1024]byte 3664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3665 3666 body := io.TeeReader(errorBody, ringBuffer) 3667 decoder := json.NewDecoder(body) 3668 decoder.UseNumber() 3669 code, message, err := restjson.GetErrorInfo(decoder) 3670 if err != nil { 3671 var snapshot bytes.Buffer 3672 io.Copy(&snapshot, ringBuffer) 3673 err = &smithy.DeserializationError{ 3674 Err: fmt.Errorf("failed to decode response body, %w", err), 3675 Snapshot: snapshot.Bytes(), 3676 } 3677 return err 3678 } 3679 3680 errorBody.Seek(0, io.SeekStart) 3681 if len(code) != 0 { 3682 errorCode = restjson.SanitizeErrorCode(code) 3683 } 3684 if len(message) != 0 { 3685 errorMessage = message 3686 } 3687 3688 switch { 3689 case strings.EqualFold("AccessDeniedException", errorCode): 3690 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3691 3692 case strings.EqualFold("ConflictException", errorCode): 3693 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3694 3695 case strings.EqualFold("InternalServerException", errorCode): 3696 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3697 3698 case strings.EqualFold("ResourceNotFoundException", errorCode): 3699 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3700 3701 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3702 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3703 3704 case strings.EqualFold("ThrottlingException", errorCode): 3705 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3706 3707 case strings.EqualFold("ValidationException", errorCode): 3708 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3709 3710 default: 3711 genericError := &smithy.GenericAPIError{ 3712 Code: errorCode, 3713 Message: errorMessage, 3714 } 3715 return genericError 3716 3717 } 3718} 3719 3720func awsRestjson1_deserializeOpDocumentGetCustomDataIdentifierOutput(v **GetCustomDataIdentifierOutput, value interface{}) error { 3721 if v == nil { 3722 return fmt.Errorf("unexpected nil of type %T", v) 3723 } 3724 if value == nil { 3725 return nil 3726 } 3727 3728 shape, ok := value.(map[string]interface{}) 3729 if !ok { 3730 return fmt.Errorf("unexpected JSON type %v", value) 3731 } 3732 3733 var sv *GetCustomDataIdentifierOutput 3734 if *v == nil { 3735 sv = &GetCustomDataIdentifierOutput{} 3736 } else { 3737 sv = *v 3738 } 3739 3740 for key, value := range shape { 3741 switch key { 3742 case "arn": 3743 if value != nil { 3744 jtv, ok := value.(string) 3745 if !ok { 3746 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 3747 } 3748 sv.Arn = ptr.String(jtv) 3749 } 3750 3751 case "createdAt": 3752 if value != nil { 3753 jtv, ok := value.(string) 3754 if !ok { 3755 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 3756 } 3757 t, err := smithytime.ParseDateTime(jtv) 3758 if err != nil { 3759 return err 3760 } 3761 sv.CreatedAt = ptr.Time(t) 3762 } 3763 3764 case "deleted": 3765 if value != nil { 3766 jtv, ok := value.(bool) 3767 if !ok { 3768 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 3769 } 3770 sv.Deleted = jtv 3771 } 3772 3773 case "description": 3774 if value != nil { 3775 jtv, ok := value.(string) 3776 if !ok { 3777 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 3778 } 3779 sv.Description = ptr.String(jtv) 3780 } 3781 3782 case "id": 3783 if value != nil { 3784 jtv, ok := value.(string) 3785 if !ok { 3786 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 3787 } 3788 sv.Id = ptr.String(jtv) 3789 } 3790 3791 case "ignoreWords": 3792 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.IgnoreWords, value); err != nil { 3793 return err 3794 } 3795 3796 case "keywords": 3797 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Keywords, value); err != nil { 3798 return err 3799 } 3800 3801 case "maximumMatchDistance": 3802 if value != nil { 3803 jtv, ok := value.(json.Number) 3804 if !ok { 3805 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 3806 } 3807 i64, err := jtv.Int64() 3808 if err != nil { 3809 return err 3810 } 3811 sv.MaximumMatchDistance = int32(i64) 3812 } 3813 3814 case "name": 3815 if value != nil { 3816 jtv, ok := value.(string) 3817 if !ok { 3818 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 3819 } 3820 sv.Name = ptr.String(jtv) 3821 } 3822 3823 case "regex": 3824 if value != nil { 3825 jtv, ok := value.(string) 3826 if !ok { 3827 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 3828 } 3829 sv.Regex = ptr.String(jtv) 3830 } 3831 3832 case "tags": 3833 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 3834 return err 3835 } 3836 3837 default: 3838 _, _ = key, value 3839 3840 } 3841 } 3842 *v = sv 3843 return nil 3844} 3845 3846type awsRestjson1_deserializeOpGetFindings struct { 3847} 3848 3849func (*awsRestjson1_deserializeOpGetFindings) ID() string { 3850 return "OperationDeserializer" 3851} 3852 3853func (m *awsRestjson1_deserializeOpGetFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3854 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3855) { 3856 out, metadata, err = next.HandleDeserialize(ctx, in) 3857 if err != nil { 3858 return out, metadata, err 3859 } 3860 3861 response, ok := out.RawResponse.(*smithyhttp.Response) 3862 if !ok { 3863 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3864 } 3865 3866 if response.StatusCode < 200 || response.StatusCode >= 300 { 3867 return out, metadata, awsRestjson1_deserializeOpErrorGetFindings(response, &metadata) 3868 } 3869 output := &GetFindingsOutput{} 3870 out.Result = output 3871 3872 var buff [1024]byte 3873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3874 3875 body := io.TeeReader(response.Body, ringBuffer) 3876 3877 decoder := json.NewDecoder(body) 3878 decoder.UseNumber() 3879 var shape interface{} 3880 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3881 var snapshot bytes.Buffer 3882 io.Copy(&snapshot, ringBuffer) 3883 err = &smithy.DeserializationError{ 3884 Err: fmt.Errorf("failed to decode response body, %w", err), 3885 Snapshot: snapshot.Bytes(), 3886 } 3887 return out, metadata, err 3888 } 3889 3890 err = awsRestjson1_deserializeOpDocumentGetFindingsOutput(&output, shape) 3891 if err != nil { 3892 var snapshot bytes.Buffer 3893 io.Copy(&snapshot, ringBuffer) 3894 return out, metadata, &smithy.DeserializationError{ 3895 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3896 Snapshot: snapshot.Bytes(), 3897 } 3898 } 3899 3900 return out, metadata, err 3901} 3902 3903func awsRestjson1_deserializeOpErrorGetFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3904 var errorBuffer bytes.Buffer 3905 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3906 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3907 } 3908 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3909 3910 errorCode := "UnknownError" 3911 errorMessage := errorCode 3912 3913 code := response.Header.Get("X-Amzn-ErrorType") 3914 if len(code) != 0 { 3915 errorCode = restjson.SanitizeErrorCode(code) 3916 } 3917 3918 var buff [1024]byte 3919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3920 3921 body := io.TeeReader(errorBody, ringBuffer) 3922 decoder := json.NewDecoder(body) 3923 decoder.UseNumber() 3924 code, message, err := restjson.GetErrorInfo(decoder) 3925 if err != nil { 3926 var snapshot bytes.Buffer 3927 io.Copy(&snapshot, ringBuffer) 3928 err = &smithy.DeserializationError{ 3929 Err: fmt.Errorf("failed to decode response body, %w", err), 3930 Snapshot: snapshot.Bytes(), 3931 } 3932 return err 3933 } 3934 3935 errorBody.Seek(0, io.SeekStart) 3936 if len(code) != 0 { 3937 errorCode = restjson.SanitizeErrorCode(code) 3938 } 3939 if len(message) != 0 { 3940 errorMessage = message 3941 } 3942 3943 switch { 3944 case strings.EqualFold("AccessDeniedException", errorCode): 3945 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3946 3947 case strings.EqualFold("ConflictException", errorCode): 3948 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3949 3950 case strings.EqualFold("InternalServerException", errorCode): 3951 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3952 3953 case strings.EqualFold("ResourceNotFoundException", errorCode): 3954 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3955 3956 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3957 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3958 3959 case strings.EqualFold("ThrottlingException", errorCode): 3960 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3961 3962 case strings.EqualFold("ValidationException", errorCode): 3963 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3964 3965 default: 3966 genericError := &smithy.GenericAPIError{ 3967 Code: errorCode, 3968 Message: errorMessage, 3969 } 3970 return genericError 3971 3972 } 3973} 3974 3975func awsRestjson1_deserializeOpDocumentGetFindingsOutput(v **GetFindingsOutput, value interface{}) error { 3976 if v == nil { 3977 return fmt.Errorf("unexpected nil of type %T", v) 3978 } 3979 if value == nil { 3980 return nil 3981 } 3982 3983 shape, ok := value.(map[string]interface{}) 3984 if !ok { 3985 return fmt.Errorf("unexpected JSON type %v", value) 3986 } 3987 3988 var sv *GetFindingsOutput 3989 if *v == nil { 3990 sv = &GetFindingsOutput{} 3991 } else { 3992 sv = *v 3993 } 3994 3995 for key, value := range shape { 3996 switch key { 3997 case "findings": 3998 if err := awsRestjson1_deserializeDocument__listOfFinding(&sv.Findings, value); err != nil { 3999 return err 4000 } 4001 4002 default: 4003 _, _ = key, value 4004 4005 } 4006 } 4007 *v = sv 4008 return nil 4009} 4010 4011type awsRestjson1_deserializeOpGetFindingsFilter struct { 4012} 4013 4014func (*awsRestjson1_deserializeOpGetFindingsFilter) ID() string { 4015 return "OperationDeserializer" 4016} 4017 4018func (m *awsRestjson1_deserializeOpGetFindingsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4019 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4020) { 4021 out, metadata, err = next.HandleDeserialize(ctx, in) 4022 if err != nil { 4023 return out, metadata, err 4024 } 4025 4026 response, ok := out.RawResponse.(*smithyhttp.Response) 4027 if !ok { 4028 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4029 } 4030 4031 if response.StatusCode < 200 || response.StatusCode >= 300 { 4032 return out, metadata, awsRestjson1_deserializeOpErrorGetFindingsFilter(response, &metadata) 4033 } 4034 output := &GetFindingsFilterOutput{} 4035 out.Result = output 4036 4037 var buff [1024]byte 4038 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4039 4040 body := io.TeeReader(response.Body, ringBuffer) 4041 4042 decoder := json.NewDecoder(body) 4043 decoder.UseNumber() 4044 var shape interface{} 4045 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4046 var snapshot bytes.Buffer 4047 io.Copy(&snapshot, ringBuffer) 4048 err = &smithy.DeserializationError{ 4049 Err: fmt.Errorf("failed to decode response body, %w", err), 4050 Snapshot: snapshot.Bytes(), 4051 } 4052 return out, metadata, err 4053 } 4054 4055 err = awsRestjson1_deserializeOpDocumentGetFindingsFilterOutput(&output, shape) 4056 if err != nil { 4057 var snapshot bytes.Buffer 4058 io.Copy(&snapshot, ringBuffer) 4059 return out, metadata, &smithy.DeserializationError{ 4060 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4061 Snapshot: snapshot.Bytes(), 4062 } 4063 } 4064 4065 return out, metadata, err 4066} 4067 4068func awsRestjson1_deserializeOpErrorGetFindingsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4069 var errorBuffer bytes.Buffer 4070 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4071 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4072 } 4073 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4074 4075 errorCode := "UnknownError" 4076 errorMessage := errorCode 4077 4078 code := response.Header.Get("X-Amzn-ErrorType") 4079 if len(code) != 0 { 4080 errorCode = restjson.SanitizeErrorCode(code) 4081 } 4082 4083 var buff [1024]byte 4084 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4085 4086 body := io.TeeReader(errorBody, ringBuffer) 4087 decoder := json.NewDecoder(body) 4088 decoder.UseNumber() 4089 code, message, err := restjson.GetErrorInfo(decoder) 4090 if err != nil { 4091 var snapshot bytes.Buffer 4092 io.Copy(&snapshot, ringBuffer) 4093 err = &smithy.DeserializationError{ 4094 Err: fmt.Errorf("failed to decode response body, %w", err), 4095 Snapshot: snapshot.Bytes(), 4096 } 4097 return err 4098 } 4099 4100 errorBody.Seek(0, io.SeekStart) 4101 if len(code) != 0 { 4102 errorCode = restjson.SanitizeErrorCode(code) 4103 } 4104 if len(message) != 0 { 4105 errorMessage = message 4106 } 4107 4108 switch { 4109 case strings.EqualFold("AccessDeniedException", errorCode): 4110 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4111 4112 case strings.EqualFold("ConflictException", errorCode): 4113 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4114 4115 case strings.EqualFold("InternalServerException", errorCode): 4116 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4117 4118 case strings.EqualFold("ResourceNotFoundException", errorCode): 4119 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4120 4121 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4122 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4123 4124 case strings.EqualFold("ThrottlingException", errorCode): 4125 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4126 4127 case strings.EqualFold("ValidationException", errorCode): 4128 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4129 4130 default: 4131 genericError := &smithy.GenericAPIError{ 4132 Code: errorCode, 4133 Message: errorMessage, 4134 } 4135 return genericError 4136 4137 } 4138} 4139 4140func awsRestjson1_deserializeOpDocumentGetFindingsFilterOutput(v **GetFindingsFilterOutput, value interface{}) error { 4141 if v == nil { 4142 return fmt.Errorf("unexpected nil of type %T", v) 4143 } 4144 if value == nil { 4145 return nil 4146 } 4147 4148 shape, ok := value.(map[string]interface{}) 4149 if !ok { 4150 return fmt.Errorf("unexpected JSON type %v", value) 4151 } 4152 4153 var sv *GetFindingsFilterOutput 4154 if *v == nil { 4155 sv = &GetFindingsFilterOutput{} 4156 } else { 4157 sv = *v 4158 } 4159 4160 for key, value := range shape { 4161 switch key { 4162 case "action": 4163 if value != nil { 4164 jtv, ok := value.(string) 4165 if !ok { 4166 return fmt.Errorf("expected FindingsFilterAction to be of type string, got %T instead", value) 4167 } 4168 sv.Action = types.FindingsFilterAction(jtv) 4169 } 4170 4171 case "arn": 4172 if value != nil { 4173 jtv, ok := value.(string) 4174 if !ok { 4175 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4176 } 4177 sv.Arn = ptr.String(jtv) 4178 } 4179 4180 case "description": 4181 if value != nil { 4182 jtv, ok := value.(string) 4183 if !ok { 4184 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4185 } 4186 sv.Description = ptr.String(jtv) 4187 } 4188 4189 case "findingCriteria": 4190 if err := awsRestjson1_deserializeDocumentFindingCriteria(&sv.FindingCriteria, value); err != nil { 4191 return err 4192 } 4193 4194 case "id": 4195 if value != nil { 4196 jtv, ok := value.(string) 4197 if !ok { 4198 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4199 } 4200 sv.Id = ptr.String(jtv) 4201 } 4202 4203 case "name": 4204 if value != nil { 4205 jtv, ok := value.(string) 4206 if !ok { 4207 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4208 } 4209 sv.Name = ptr.String(jtv) 4210 } 4211 4212 case "position": 4213 if value != nil { 4214 jtv, ok := value.(json.Number) 4215 if !ok { 4216 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 4217 } 4218 i64, err := jtv.Int64() 4219 if err != nil { 4220 return err 4221 } 4222 sv.Position = int32(i64) 4223 } 4224 4225 case "tags": 4226 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 4227 return err 4228 } 4229 4230 default: 4231 _, _ = key, value 4232 4233 } 4234 } 4235 *v = sv 4236 return nil 4237} 4238 4239type awsRestjson1_deserializeOpGetFindingStatistics struct { 4240} 4241 4242func (*awsRestjson1_deserializeOpGetFindingStatistics) ID() string { 4243 return "OperationDeserializer" 4244} 4245 4246func (m *awsRestjson1_deserializeOpGetFindingStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4247 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4248) { 4249 out, metadata, err = next.HandleDeserialize(ctx, in) 4250 if err != nil { 4251 return out, metadata, err 4252 } 4253 4254 response, ok := out.RawResponse.(*smithyhttp.Response) 4255 if !ok { 4256 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4257 } 4258 4259 if response.StatusCode < 200 || response.StatusCode >= 300 { 4260 return out, metadata, awsRestjson1_deserializeOpErrorGetFindingStatistics(response, &metadata) 4261 } 4262 output := &GetFindingStatisticsOutput{} 4263 out.Result = output 4264 4265 var buff [1024]byte 4266 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4267 4268 body := io.TeeReader(response.Body, ringBuffer) 4269 4270 decoder := json.NewDecoder(body) 4271 decoder.UseNumber() 4272 var shape interface{} 4273 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4274 var snapshot bytes.Buffer 4275 io.Copy(&snapshot, ringBuffer) 4276 err = &smithy.DeserializationError{ 4277 Err: fmt.Errorf("failed to decode response body, %w", err), 4278 Snapshot: snapshot.Bytes(), 4279 } 4280 return out, metadata, err 4281 } 4282 4283 err = awsRestjson1_deserializeOpDocumentGetFindingStatisticsOutput(&output, shape) 4284 if err != nil { 4285 var snapshot bytes.Buffer 4286 io.Copy(&snapshot, ringBuffer) 4287 return out, metadata, &smithy.DeserializationError{ 4288 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4289 Snapshot: snapshot.Bytes(), 4290 } 4291 } 4292 4293 return out, metadata, err 4294} 4295 4296func awsRestjson1_deserializeOpErrorGetFindingStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4297 var errorBuffer bytes.Buffer 4298 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4299 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4300 } 4301 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4302 4303 errorCode := "UnknownError" 4304 errorMessage := errorCode 4305 4306 code := response.Header.Get("X-Amzn-ErrorType") 4307 if len(code) != 0 { 4308 errorCode = restjson.SanitizeErrorCode(code) 4309 } 4310 4311 var buff [1024]byte 4312 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4313 4314 body := io.TeeReader(errorBody, ringBuffer) 4315 decoder := json.NewDecoder(body) 4316 decoder.UseNumber() 4317 code, message, err := restjson.GetErrorInfo(decoder) 4318 if err != nil { 4319 var snapshot bytes.Buffer 4320 io.Copy(&snapshot, ringBuffer) 4321 err = &smithy.DeserializationError{ 4322 Err: fmt.Errorf("failed to decode response body, %w", err), 4323 Snapshot: snapshot.Bytes(), 4324 } 4325 return err 4326 } 4327 4328 errorBody.Seek(0, io.SeekStart) 4329 if len(code) != 0 { 4330 errorCode = restjson.SanitizeErrorCode(code) 4331 } 4332 if len(message) != 0 { 4333 errorMessage = message 4334 } 4335 4336 switch { 4337 case strings.EqualFold("AccessDeniedException", errorCode): 4338 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4339 4340 case strings.EqualFold("ConflictException", errorCode): 4341 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4342 4343 case strings.EqualFold("InternalServerException", errorCode): 4344 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4345 4346 case strings.EqualFold("ResourceNotFoundException", errorCode): 4347 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4348 4349 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4350 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4351 4352 case strings.EqualFold("ThrottlingException", errorCode): 4353 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4354 4355 case strings.EqualFold("ValidationException", errorCode): 4356 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4357 4358 default: 4359 genericError := &smithy.GenericAPIError{ 4360 Code: errorCode, 4361 Message: errorMessage, 4362 } 4363 return genericError 4364 4365 } 4366} 4367 4368func awsRestjson1_deserializeOpDocumentGetFindingStatisticsOutput(v **GetFindingStatisticsOutput, value interface{}) error { 4369 if v == nil { 4370 return fmt.Errorf("unexpected nil of type %T", v) 4371 } 4372 if value == nil { 4373 return nil 4374 } 4375 4376 shape, ok := value.(map[string]interface{}) 4377 if !ok { 4378 return fmt.Errorf("unexpected JSON type %v", value) 4379 } 4380 4381 var sv *GetFindingStatisticsOutput 4382 if *v == nil { 4383 sv = &GetFindingStatisticsOutput{} 4384 } else { 4385 sv = *v 4386 } 4387 4388 for key, value := range shape { 4389 switch key { 4390 case "countsByGroup": 4391 if err := awsRestjson1_deserializeDocument__listOfGroupCount(&sv.CountsByGroup, value); err != nil { 4392 return err 4393 } 4394 4395 default: 4396 _, _ = key, value 4397 4398 } 4399 } 4400 *v = sv 4401 return nil 4402} 4403 4404type awsRestjson1_deserializeOpGetInvitationsCount struct { 4405} 4406 4407func (*awsRestjson1_deserializeOpGetInvitationsCount) ID() string { 4408 return "OperationDeserializer" 4409} 4410 4411func (m *awsRestjson1_deserializeOpGetInvitationsCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4412 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4413) { 4414 out, metadata, err = next.HandleDeserialize(ctx, in) 4415 if err != nil { 4416 return out, metadata, err 4417 } 4418 4419 response, ok := out.RawResponse.(*smithyhttp.Response) 4420 if !ok { 4421 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4422 } 4423 4424 if response.StatusCode < 200 || response.StatusCode >= 300 { 4425 return out, metadata, awsRestjson1_deserializeOpErrorGetInvitationsCount(response, &metadata) 4426 } 4427 output := &GetInvitationsCountOutput{} 4428 out.Result = output 4429 4430 var buff [1024]byte 4431 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4432 4433 body := io.TeeReader(response.Body, ringBuffer) 4434 4435 decoder := json.NewDecoder(body) 4436 decoder.UseNumber() 4437 var shape interface{} 4438 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4439 var snapshot bytes.Buffer 4440 io.Copy(&snapshot, ringBuffer) 4441 err = &smithy.DeserializationError{ 4442 Err: fmt.Errorf("failed to decode response body, %w", err), 4443 Snapshot: snapshot.Bytes(), 4444 } 4445 return out, metadata, err 4446 } 4447 4448 err = awsRestjson1_deserializeOpDocumentGetInvitationsCountOutput(&output, shape) 4449 if err != nil { 4450 var snapshot bytes.Buffer 4451 io.Copy(&snapshot, ringBuffer) 4452 return out, metadata, &smithy.DeserializationError{ 4453 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4454 Snapshot: snapshot.Bytes(), 4455 } 4456 } 4457 4458 return out, metadata, err 4459} 4460 4461func awsRestjson1_deserializeOpErrorGetInvitationsCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4462 var errorBuffer bytes.Buffer 4463 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4464 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4465 } 4466 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4467 4468 errorCode := "UnknownError" 4469 errorMessage := errorCode 4470 4471 code := response.Header.Get("X-Amzn-ErrorType") 4472 if len(code) != 0 { 4473 errorCode = restjson.SanitizeErrorCode(code) 4474 } 4475 4476 var buff [1024]byte 4477 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4478 4479 body := io.TeeReader(errorBody, ringBuffer) 4480 decoder := json.NewDecoder(body) 4481 decoder.UseNumber() 4482 code, message, err := restjson.GetErrorInfo(decoder) 4483 if err != nil { 4484 var snapshot bytes.Buffer 4485 io.Copy(&snapshot, ringBuffer) 4486 err = &smithy.DeserializationError{ 4487 Err: fmt.Errorf("failed to decode response body, %w", err), 4488 Snapshot: snapshot.Bytes(), 4489 } 4490 return err 4491 } 4492 4493 errorBody.Seek(0, io.SeekStart) 4494 if len(code) != 0 { 4495 errorCode = restjson.SanitizeErrorCode(code) 4496 } 4497 if len(message) != 0 { 4498 errorMessage = message 4499 } 4500 4501 switch { 4502 case strings.EqualFold("AccessDeniedException", errorCode): 4503 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4504 4505 case strings.EqualFold("ConflictException", errorCode): 4506 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4507 4508 case strings.EqualFold("InternalServerException", errorCode): 4509 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4510 4511 case strings.EqualFold("ResourceNotFoundException", errorCode): 4512 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4513 4514 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4515 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4516 4517 case strings.EqualFold("ThrottlingException", errorCode): 4518 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4519 4520 case strings.EqualFold("ValidationException", errorCode): 4521 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4522 4523 default: 4524 genericError := &smithy.GenericAPIError{ 4525 Code: errorCode, 4526 Message: errorMessage, 4527 } 4528 return genericError 4529 4530 } 4531} 4532 4533func awsRestjson1_deserializeOpDocumentGetInvitationsCountOutput(v **GetInvitationsCountOutput, value interface{}) error { 4534 if v == nil { 4535 return fmt.Errorf("unexpected nil of type %T", v) 4536 } 4537 if value == nil { 4538 return nil 4539 } 4540 4541 shape, ok := value.(map[string]interface{}) 4542 if !ok { 4543 return fmt.Errorf("unexpected JSON type %v", value) 4544 } 4545 4546 var sv *GetInvitationsCountOutput 4547 if *v == nil { 4548 sv = &GetInvitationsCountOutput{} 4549 } else { 4550 sv = *v 4551 } 4552 4553 for key, value := range shape { 4554 switch key { 4555 case "invitationsCount": 4556 if value != nil { 4557 jtv, ok := value.(json.Number) 4558 if !ok { 4559 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 4560 } 4561 i64, err := jtv.Int64() 4562 if err != nil { 4563 return err 4564 } 4565 sv.InvitationsCount = i64 4566 } 4567 4568 default: 4569 _, _ = key, value 4570 4571 } 4572 } 4573 *v = sv 4574 return nil 4575} 4576 4577type awsRestjson1_deserializeOpGetMacieSession struct { 4578} 4579 4580func (*awsRestjson1_deserializeOpGetMacieSession) ID() string { 4581 return "OperationDeserializer" 4582} 4583 4584func (m *awsRestjson1_deserializeOpGetMacieSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4585 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4586) { 4587 out, metadata, err = next.HandleDeserialize(ctx, in) 4588 if err != nil { 4589 return out, metadata, err 4590 } 4591 4592 response, ok := out.RawResponse.(*smithyhttp.Response) 4593 if !ok { 4594 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4595 } 4596 4597 if response.StatusCode < 200 || response.StatusCode >= 300 { 4598 return out, metadata, awsRestjson1_deserializeOpErrorGetMacieSession(response, &metadata) 4599 } 4600 output := &GetMacieSessionOutput{} 4601 out.Result = output 4602 4603 var buff [1024]byte 4604 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4605 4606 body := io.TeeReader(response.Body, ringBuffer) 4607 4608 decoder := json.NewDecoder(body) 4609 decoder.UseNumber() 4610 var shape interface{} 4611 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4612 var snapshot bytes.Buffer 4613 io.Copy(&snapshot, ringBuffer) 4614 err = &smithy.DeserializationError{ 4615 Err: fmt.Errorf("failed to decode response body, %w", err), 4616 Snapshot: snapshot.Bytes(), 4617 } 4618 return out, metadata, err 4619 } 4620 4621 err = awsRestjson1_deserializeOpDocumentGetMacieSessionOutput(&output, shape) 4622 if err != nil { 4623 var snapshot bytes.Buffer 4624 io.Copy(&snapshot, ringBuffer) 4625 return out, metadata, &smithy.DeserializationError{ 4626 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4627 Snapshot: snapshot.Bytes(), 4628 } 4629 } 4630 4631 return out, metadata, err 4632} 4633 4634func awsRestjson1_deserializeOpErrorGetMacieSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4635 var errorBuffer bytes.Buffer 4636 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4637 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4638 } 4639 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4640 4641 errorCode := "UnknownError" 4642 errorMessage := errorCode 4643 4644 code := response.Header.Get("X-Amzn-ErrorType") 4645 if len(code) != 0 { 4646 errorCode = restjson.SanitizeErrorCode(code) 4647 } 4648 4649 var buff [1024]byte 4650 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4651 4652 body := io.TeeReader(errorBody, ringBuffer) 4653 decoder := json.NewDecoder(body) 4654 decoder.UseNumber() 4655 code, message, err := restjson.GetErrorInfo(decoder) 4656 if err != nil { 4657 var snapshot bytes.Buffer 4658 io.Copy(&snapshot, ringBuffer) 4659 err = &smithy.DeserializationError{ 4660 Err: fmt.Errorf("failed to decode response body, %w", err), 4661 Snapshot: snapshot.Bytes(), 4662 } 4663 return err 4664 } 4665 4666 errorBody.Seek(0, io.SeekStart) 4667 if len(code) != 0 { 4668 errorCode = restjson.SanitizeErrorCode(code) 4669 } 4670 if len(message) != 0 { 4671 errorMessage = message 4672 } 4673 4674 switch { 4675 case strings.EqualFold("AccessDeniedException", errorCode): 4676 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4677 4678 case strings.EqualFold("ConflictException", errorCode): 4679 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4680 4681 case strings.EqualFold("InternalServerException", errorCode): 4682 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4683 4684 case strings.EqualFold("ResourceNotFoundException", errorCode): 4685 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4686 4687 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4688 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4689 4690 case strings.EqualFold("ThrottlingException", errorCode): 4691 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4692 4693 case strings.EqualFold("ValidationException", errorCode): 4694 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4695 4696 default: 4697 genericError := &smithy.GenericAPIError{ 4698 Code: errorCode, 4699 Message: errorMessage, 4700 } 4701 return genericError 4702 4703 } 4704} 4705 4706func awsRestjson1_deserializeOpDocumentGetMacieSessionOutput(v **GetMacieSessionOutput, value interface{}) error { 4707 if v == nil { 4708 return fmt.Errorf("unexpected nil of type %T", v) 4709 } 4710 if value == nil { 4711 return nil 4712 } 4713 4714 shape, ok := value.(map[string]interface{}) 4715 if !ok { 4716 return fmt.Errorf("unexpected JSON type %v", value) 4717 } 4718 4719 var sv *GetMacieSessionOutput 4720 if *v == nil { 4721 sv = &GetMacieSessionOutput{} 4722 } else { 4723 sv = *v 4724 } 4725 4726 for key, value := range shape { 4727 switch key { 4728 case "createdAt": 4729 if value != nil { 4730 jtv, ok := value.(string) 4731 if !ok { 4732 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 4733 } 4734 t, err := smithytime.ParseDateTime(jtv) 4735 if err != nil { 4736 return err 4737 } 4738 sv.CreatedAt = ptr.Time(t) 4739 } 4740 4741 case "findingPublishingFrequency": 4742 if value != nil { 4743 jtv, ok := value.(string) 4744 if !ok { 4745 return fmt.Errorf("expected FindingPublishingFrequency to be of type string, got %T instead", value) 4746 } 4747 sv.FindingPublishingFrequency = types.FindingPublishingFrequency(jtv) 4748 } 4749 4750 case "serviceRole": 4751 if value != nil { 4752 jtv, ok := value.(string) 4753 if !ok { 4754 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4755 } 4756 sv.ServiceRole = ptr.String(jtv) 4757 } 4758 4759 case "status": 4760 if value != nil { 4761 jtv, ok := value.(string) 4762 if !ok { 4763 return fmt.Errorf("expected MacieStatus to be of type string, got %T instead", value) 4764 } 4765 sv.Status = types.MacieStatus(jtv) 4766 } 4767 4768 case "updatedAt": 4769 if value != nil { 4770 jtv, ok := value.(string) 4771 if !ok { 4772 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 4773 } 4774 t, err := smithytime.ParseDateTime(jtv) 4775 if err != nil { 4776 return err 4777 } 4778 sv.UpdatedAt = ptr.Time(t) 4779 } 4780 4781 default: 4782 _, _ = key, value 4783 4784 } 4785 } 4786 *v = sv 4787 return nil 4788} 4789 4790type awsRestjson1_deserializeOpGetMasterAccount struct { 4791} 4792 4793func (*awsRestjson1_deserializeOpGetMasterAccount) ID() string { 4794 return "OperationDeserializer" 4795} 4796 4797func (m *awsRestjson1_deserializeOpGetMasterAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4798 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4799) { 4800 out, metadata, err = next.HandleDeserialize(ctx, in) 4801 if err != nil { 4802 return out, metadata, err 4803 } 4804 4805 response, ok := out.RawResponse.(*smithyhttp.Response) 4806 if !ok { 4807 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4808 } 4809 4810 if response.StatusCode < 200 || response.StatusCode >= 300 { 4811 return out, metadata, awsRestjson1_deserializeOpErrorGetMasterAccount(response, &metadata) 4812 } 4813 output := &GetMasterAccountOutput{} 4814 out.Result = output 4815 4816 var buff [1024]byte 4817 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4818 4819 body := io.TeeReader(response.Body, ringBuffer) 4820 4821 decoder := json.NewDecoder(body) 4822 decoder.UseNumber() 4823 var shape interface{} 4824 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4825 var snapshot bytes.Buffer 4826 io.Copy(&snapshot, ringBuffer) 4827 err = &smithy.DeserializationError{ 4828 Err: fmt.Errorf("failed to decode response body, %w", err), 4829 Snapshot: snapshot.Bytes(), 4830 } 4831 return out, metadata, err 4832 } 4833 4834 err = awsRestjson1_deserializeOpDocumentGetMasterAccountOutput(&output, shape) 4835 if err != nil { 4836 var snapshot bytes.Buffer 4837 io.Copy(&snapshot, ringBuffer) 4838 return out, metadata, &smithy.DeserializationError{ 4839 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4840 Snapshot: snapshot.Bytes(), 4841 } 4842 } 4843 4844 return out, metadata, err 4845} 4846 4847func awsRestjson1_deserializeOpErrorGetMasterAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4848 var errorBuffer bytes.Buffer 4849 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4850 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4851 } 4852 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4853 4854 errorCode := "UnknownError" 4855 errorMessage := errorCode 4856 4857 code := response.Header.Get("X-Amzn-ErrorType") 4858 if len(code) != 0 { 4859 errorCode = restjson.SanitizeErrorCode(code) 4860 } 4861 4862 var buff [1024]byte 4863 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4864 4865 body := io.TeeReader(errorBody, ringBuffer) 4866 decoder := json.NewDecoder(body) 4867 decoder.UseNumber() 4868 code, message, err := restjson.GetErrorInfo(decoder) 4869 if err != nil { 4870 var snapshot bytes.Buffer 4871 io.Copy(&snapshot, ringBuffer) 4872 err = &smithy.DeserializationError{ 4873 Err: fmt.Errorf("failed to decode response body, %w", err), 4874 Snapshot: snapshot.Bytes(), 4875 } 4876 return err 4877 } 4878 4879 errorBody.Seek(0, io.SeekStart) 4880 if len(code) != 0 { 4881 errorCode = restjson.SanitizeErrorCode(code) 4882 } 4883 if len(message) != 0 { 4884 errorMessage = message 4885 } 4886 4887 switch { 4888 case strings.EqualFold("AccessDeniedException", errorCode): 4889 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4890 4891 case strings.EqualFold("ConflictException", errorCode): 4892 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4893 4894 case strings.EqualFold("InternalServerException", errorCode): 4895 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4896 4897 case strings.EqualFold("ResourceNotFoundException", errorCode): 4898 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4899 4900 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4901 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4902 4903 case strings.EqualFold("ThrottlingException", errorCode): 4904 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4905 4906 case strings.EqualFold("ValidationException", errorCode): 4907 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4908 4909 default: 4910 genericError := &smithy.GenericAPIError{ 4911 Code: errorCode, 4912 Message: errorMessage, 4913 } 4914 return genericError 4915 4916 } 4917} 4918 4919func awsRestjson1_deserializeOpDocumentGetMasterAccountOutput(v **GetMasterAccountOutput, value interface{}) error { 4920 if v == nil { 4921 return fmt.Errorf("unexpected nil of type %T", v) 4922 } 4923 if value == nil { 4924 return nil 4925 } 4926 4927 shape, ok := value.(map[string]interface{}) 4928 if !ok { 4929 return fmt.Errorf("unexpected JSON type %v", value) 4930 } 4931 4932 var sv *GetMasterAccountOutput 4933 if *v == nil { 4934 sv = &GetMasterAccountOutput{} 4935 } else { 4936 sv = *v 4937 } 4938 4939 for key, value := range shape { 4940 switch key { 4941 case "master": 4942 if err := awsRestjson1_deserializeDocumentInvitation(&sv.Master, value); err != nil { 4943 return err 4944 } 4945 4946 default: 4947 _, _ = key, value 4948 4949 } 4950 } 4951 *v = sv 4952 return nil 4953} 4954 4955type awsRestjson1_deserializeOpGetMember struct { 4956} 4957 4958func (*awsRestjson1_deserializeOpGetMember) ID() string { 4959 return "OperationDeserializer" 4960} 4961 4962func (m *awsRestjson1_deserializeOpGetMember) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4963 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4964) { 4965 out, metadata, err = next.HandleDeserialize(ctx, in) 4966 if err != nil { 4967 return out, metadata, err 4968 } 4969 4970 response, ok := out.RawResponse.(*smithyhttp.Response) 4971 if !ok { 4972 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4973 } 4974 4975 if response.StatusCode < 200 || response.StatusCode >= 300 { 4976 return out, metadata, awsRestjson1_deserializeOpErrorGetMember(response, &metadata) 4977 } 4978 output := &GetMemberOutput{} 4979 out.Result = output 4980 4981 var buff [1024]byte 4982 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4983 4984 body := io.TeeReader(response.Body, ringBuffer) 4985 4986 decoder := json.NewDecoder(body) 4987 decoder.UseNumber() 4988 var shape interface{} 4989 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4990 var snapshot bytes.Buffer 4991 io.Copy(&snapshot, ringBuffer) 4992 err = &smithy.DeserializationError{ 4993 Err: fmt.Errorf("failed to decode response body, %w", err), 4994 Snapshot: snapshot.Bytes(), 4995 } 4996 return out, metadata, err 4997 } 4998 4999 err = awsRestjson1_deserializeOpDocumentGetMemberOutput(&output, shape) 5000 if err != nil { 5001 var snapshot bytes.Buffer 5002 io.Copy(&snapshot, ringBuffer) 5003 return out, metadata, &smithy.DeserializationError{ 5004 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5005 Snapshot: snapshot.Bytes(), 5006 } 5007 } 5008 5009 return out, metadata, err 5010} 5011 5012func awsRestjson1_deserializeOpErrorGetMember(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5013 var errorBuffer bytes.Buffer 5014 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5015 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5016 } 5017 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5018 5019 errorCode := "UnknownError" 5020 errorMessage := errorCode 5021 5022 code := response.Header.Get("X-Amzn-ErrorType") 5023 if len(code) != 0 { 5024 errorCode = restjson.SanitizeErrorCode(code) 5025 } 5026 5027 var buff [1024]byte 5028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5029 5030 body := io.TeeReader(errorBody, ringBuffer) 5031 decoder := json.NewDecoder(body) 5032 decoder.UseNumber() 5033 code, message, err := restjson.GetErrorInfo(decoder) 5034 if err != nil { 5035 var snapshot bytes.Buffer 5036 io.Copy(&snapshot, ringBuffer) 5037 err = &smithy.DeserializationError{ 5038 Err: fmt.Errorf("failed to decode response body, %w", err), 5039 Snapshot: snapshot.Bytes(), 5040 } 5041 return err 5042 } 5043 5044 errorBody.Seek(0, io.SeekStart) 5045 if len(code) != 0 { 5046 errorCode = restjson.SanitizeErrorCode(code) 5047 } 5048 if len(message) != 0 { 5049 errorMessage = message 5050 } 5051 5052 switch { 5053 case strings.EqualFold("AccessDeniedException", errorCode): 5054 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5055 5056 case strings.EqualFold("ConflictException", errorCode): 5057 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5058 5059 case strings.EqualFold("InternalServerException", errorCode): 5060 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5061 5062 case strings.EqualFold("ResourceNotFoundException", errorCode): 5063 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5064 5065 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5066 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5067 5068 case strings.EqualFold("ThrottlingException", errorCode): 5069 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5070 5071 case strings.EqualFold("ValidationException", errorCode): 5072 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5073 5074 default: 5075 genericError := &smithy.GenericAPIError{ 5076 Code: errorCode, 5077 Message: errorMessage, 5078 } 5079 return genericError 5080 5081 } 5082} 5083 5084func awsRestjson1_deserializeOpDocumentGetMemberOutput(v **GetMemberOutput, value interface{}) error { 5085 if v == nil { 5086 return fmt.Errorf("unexpected nil of type %T", v) 5087 } 5088 if value == nil { 5089 return nil 5090 } 5091 5092 shape, ok := value.(map[string]interface{}) 5093 if !ok { 5094 return fmt.Errorf("unexpected JSON type %v", value) 5095 } 5096 5097 var sv *GetMemberOutput 5098 if *v == nil { 5099 sv = &GetMemberOutput{} 5100 } else { 5101 sv = *v 5102 } 5103 5104 for key, value := range shape { 5105 switch key { 5106 case "accountId": 5107 if value != nil { 5108 jtv, ok := value.(string) 5109 if !ok { 5110 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5111 } 5112 sv.AccountId = ptr.String(jtv) 5113 } 5114 5115 case "arn": 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.Arn = ptr.String(jtv) 5122 } 5123 5124 case "email": 5125 if value != nil { 5126 jtv, ok := value.(string) 5127 if !ok { 5128 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5129 } 5130 sv.Email = ptr.String(jtv) 5131 } 5132 5133 case "invitedAt": 5134 if value != nil { 5135 jtv, ok := value.(string) 5136 if !ok { 5137 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 5138 } 5139 t, err := smithytime.ParseDateTime(jtv) 5140 if err != nil { 5141 return err 5142 } 5143 sv.InvitedAt = ptr.Time(t) 5144 } 5145 5146 case "masterAccountId": 5147 if value != nil { 5148 jtv, ok := value.(string) 5149 if !ok { 5150 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5151 } 5152 sv.MasterAccountId = ptr.String(jtv) 5153 } 5154 5155 case "relationshipStatus": 5156 if value != nil { 5157 jtv, ok := value.(string) 5158 if !ok { 5159 return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value) 5160 } 5161 sv.RelationshipStatus = types.RelationshipStatus(jtv) 5162 } 5163 5164 case "tags": 5165 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 5166 return err 5167 } 5168 5169 case "updatedAt": 5170 if value != nil { 5171 jtv, ok := value.(string) 5172 if !ok { 5173 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 5174 } 5175 t, err := smithytime.ParseDateTime(jtv) 5176 if err != nil { 5177 return err 5178 } 5179 sv.UpdatedAt = ptr.Time(t) 5180 } 5181 5182 default: 5183 _, _ = key, value 5184 5185 } 5186 } 5187 *v = sv 5188 return nil 5189} 5190 5191type awsRestjson1_deserializeOpGetUsageStatistics struct { 5192} 5193 5194func (*awsRestjson1_deserializeOpGetUsageStatistics) ID() string { 5195 return "OperationDeserializer" 5196} 5197 5198func (m *awsRestjson1_deserializeOpGetUsageStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5199 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5200) { 5201 out, metadata, err = next.HandleDeserialize(ctx, in) 5202 if err != nil { 5203 return out, metadata, err 5204 } 5205 5206 response, ok := out.RawResponse.(*smithyhttp.Response) 5207 if !ok { 5208 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5209 } 5210 5211 if response.StatusCode < 200 || response.StatusCode >= 300 { 5212 return out, metadata, awsRestjson1_deserializeOpErrorGetUsageStatistics(response, &metadata) 5213 } 5214 output := &GetUsageStatisticsOutput{} 5215 out.Result = output 5216 5217 var buff [1024]byte 5218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5219 5220 body := io.TeeReader(response.Body, ringBuffer) 5221 5222 decoder := json.NewDecoder(body) 5223 decoder.UseNumber() 5224 var shape interface{} 5225 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5226 var snapshot bytes.Buffer 5227 io.Copy(&snapshot, ringBuffer) 5228 err = &smithy.DeserializationError{ 5229 Err: fmt.Errorf("failed to decode response body, %w", err), 5230 Snapshot: snapshot.Bytes(), 5231 } 5232 return out, metadata, err 5233 } 5234 5235 err = awsRestjson1_deserializeOpDocumentGetUsageStatisticsOutput(&output, shape) 5236 if err != nil { 5237 var snapshot bytes.Buffer 5238 io.Copy(&snapshot, ringBuffer) 5239 return out, metadata, &smithy.DeserializationError{ 5240 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5241 Snapshot: snapshot.Bytes(), 5242 } 5243 } 5244 5245 return out, metadata, err 5246} 5247 5248func awsRestjson1_deserializeOpErrorGetUsageStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5249 var errorBuffer bytes.Buffer 5250 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5251 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5252 } 5253 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5254 5255 errorCode := "UnknownError" 5256 errorMessage := errorCode 5257 5258 code := response.Header.Get("X-Amzn-ErrorType") 5259 if len(code) != 0 { 5260 errorCode = restjson.SanitizeErrorCode(code) 5261 } 5262 5263 var buff [1024]byte 5264 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5265 5266 body := io.TeeReader(errorBody, ringBuffer) 5267 decoder := json.NewDecoder(body) 5268 decoder.UseNumber() 5269 code, message, err := restjson.GetErrorInfo(decoder) 5270 if err != nil { 5271 var snapshot bytes.Buffer 5272 io.Copy(&snapshot, ringBuffer) 5273 err = &smithy.DeserializationError{ 5274 Err: fmt.Errorf("failed to decode response body, %w", err), 5275 Snapshot: snapshot.Bytes(), 5276 } 5277 return err 5278 } 5279 5280 errorBody.Seek(0, io.SeekStart) 5281 if len(code) != 0 { 5282 errorCode = restjson.SanitizeErrorCode(code) 5283 } 5284 if len(message) != 0 { 5285 errorMessage = message 5286 } 5287 5288 switch { 5289 case strings.EqualFold("AccessDeniedException", errorCode): 5290 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5291 5292 case strings.EqualFold("ConflictException", errorCode): 5293 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5294 5295 case strings.EqualFold("InternalServerException", errorCode): 5296 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5297 5298 case strings.EqualFold("ResourceNotFoundException", errorCode): 5299 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5300 5301 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5302 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5303 5304 case strings.EqualFold("ThrottlingException", errorCode): 5305 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5306 5307 case strings.EqualFold("ValidationException", errorCode): 5308 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5309 5310 default: 5311 genericError := &smithy.GenericAPIError{ 5312 Code: errorCode, 5313 Message: errorMessage, 5314 } 5315 return genericError 5316 5317 } 5318} 5319 5320func awsRestjson1_deserializeOpDocumentGetUsageStatisticsOutput(v **GetUsageStatisticsOutput, value interface{}) error { 5321 if v == nil { 5322 return fmt.Errorf("unexpected nil of type %T", v) 5323 } 5324 if value == nil { 5325 return nil 5326 } 5327 5328 shape, ok := value.(map[string]interface{}) 5329 if !ok { 5330 return fmt.Errorf("unexpected JSON type %v", value) 5331 } 5332 5333 var sv *GetUsageStatisticsOutput 5334 if *v == nil { 5335 sv = &GetUsageStatisticsOutput{} 5336 } else { 5337 sv = *v 5338 } 5339 5340 for key, value := range shape { 5341 switch key { 5342 case "nextToken": 5343 if value != nil { 5344 jtv, ok := value.(string) 5345 if !ok { 5346 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5347 } 5348 sv.NextToken = ptr.String(jtv) 5349 } 5350 5351 case "records": 5352 if err := awsRestjson1_deserializeDocument__listOfUsageRecord(&sv.Records, value); err != nil { 5353 return err 5354 } 5355 5356 default: 5357 _, _ = key, value 5358 5359 } 5360 } 5361 *v = sv 5362 return nil 5363} 5364 5365type awsRestjson1_deserializeOpGetUsageTotals struct { 5366} 5367 5368func (*awsRestjson1_deserializeOpGetUsageTotals) ID() string { 5369 return "OperationDeserializer" 5370} 5371 5372func (m *awsRestjson1_deserializeOpGetUsageTotals) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5373 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5374) { 5375 out, metadata, err = next.HandleDeserialize(ctx, in) 5376 if err != nil { 5377 return out, metadata, err 5378 } 5379 5380 response, ok := out.RawResponse.(*smithyhttp.Response) 5381 if !ok { 5382 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5383 } 5384 5385 if response.StatusCode < 200 || response.StatusCode >= 300 { 5386 return out, metadata, awsRestjson1_deserializeOpErrorGetUsageTotals(response, &metadata) 5387 } 5388 output := &GetUsageTotalsOutput{} 5389 out.Result = output 5390 5391 var buff [1024]byte 5392 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5393 5394 body := io.TeeReader(response.Body, ringBuffer) 5395 5396 decoder := json.NewDecoder(body) 5397 decoder.UseNumber() 5398 var shape interface{} 5399 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5400 var snapshot bytes.Buffer 5401 io.Copy(&snapshot, ringBuffer) 5402 err = &smithy.DeserializationError{ 5403 Err: fmt.Errorf("failed to decode response body, %w", err), 5404 Snapshot: snapshot.Bytes(), 5405 } 5406 return out, metadata, err 5407 } 5408 5409 err = awsRestjson1_deserializeOpDocumentGetUsageTotalsOutput(&output, shape) 5410 if err != nil { 5411 var snapshot bytes.Buffer 5412 io.Copy(&snapshot, ringBuffer) 5413 return out, metadata, &smithy.DeserializationError{ 5414 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5415 Snapshot: snapshot.Bytes(), 5416 } 5417 } 5418 5419 return out, metadata, err 5420} 5421 5422func awsRestjson1_deserializeOpErrorGetUsageTotals(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5423 var errorBuffer bytes.Buffer 5424 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5425 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5426 } 5427 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5428 5429 errorCode := "UnknownError" 5430 errorMessage := errorCode 5431 5432 code := response.Header.Get("X-Amzn-ErrorType") 5433 if len(code) != 0 { 5434 errorCode = restjson.SanitizeErrorCode(code) 5435 } 5436 5437 var buff [1024]byte 5438 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5439 5440 body := io.TeeReader(errorBody, ringBuffer) 5441 decoder := json.NewDecoder(body) 5442 decoder.UseNumber() 5443 code, message, err := restjson.GetErrorInfo(decoder) 5444 if err != nil { 5445 var snapshot bytes.Buffer 5446 io.Copy(&snapshot, ringBuffer) 5447 err = &smithy.DeserializationError{ 5448 Err: fmt.Errorf("failed to decode response body, %w", err), 5449 Snapshot: snapshot.Bytes(), 5450 } 5451 return err 5452 } 5453 5454 errorBody.Seek(0, io.SeekStart) 5455 if len(code) != 0 { 5456 errorCode = restjson.SanitizeErrorCode(code) 5457 } 5458 if len(message) != 0 { 5459 errorMessage = message 5460 } 5461 5462 switch { 5463 case strings.EqualFold("AccessDeniedException", errorCode): 5464 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5465 5466 case strings.EqualFold("ConflictException", errorCode): 5467 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5468 5469 case strings.EqualFold("InternalServerException", errorCode): 5470 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5471 5472 case strings.EqualFold("ResourceNotFoundException", errorCode): 5473 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5474 5475 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5476 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5477 5478 case strings.EqualFold("ThrottlingException", errorCode): 5479 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5480 5481 case strings.EqualFold("ValidationException", errorCode): 5482 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5483 5484 default: 5485 genericError := &smithy.GenericAPIError{ 5486 Code: errorCode, 5487 Message: errorMessage, 5488 } 5489 return genericError 5490 5491 } 5492} 5493 5494func awsRestjson1_deserializeOpDocumentGetUsageTotalsOutput(v **GetUsageTotalsOutput, value interface{}) error { 5495 if v == nil { 5496 return fmt.Errorf("unexpected nil of type %T", v) 5497 } 5498 if value == nil { 5499 return nil 5500 } 5501 5502 shape, ok := value.(map[string]interface{}) 5503 if !ok { 5504 return fmt.Errorf("unexpected JSON type %v", value) 5505 } 5506 5507 var sv *GetUsageTotalsOutput 5508 if *v == nil { 5509 sv = &GetUsageTotalsOutput{} 5510 } else { 5511 sv = *v 5512 } 5513 5514 for key, value := range shape { 5515 switch key { 5516 case "usageTotals": 5517 if err := awsRestjson1_deserializeDocument__listOfUsageTotal(&sv.UsageTotals, value); err != nil { 5518 return err 5519 } 5520 5521 default: 5522 _, _ = key, value 5523 5524 } 5525 } 5526 *v = sv 5527 return nil 5528} 5529 5530type awsRestjson1_deserializeOpListClassificationJobs struct { 5531} 5532 5533func (*awsRestjson1_deserializeOpListClassificationJobs) ID() string { 5534 return "OperationDeserializer" 5535} 5536 5537func (m *awsRestjson1_deserializeOpListClassificationJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5538 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5539) { 5540 out, metadata, err = next.HandleDeserialize(ctx, in) 5541 if err != nil { 5542 return out, metadata, err 5543 } 5544 5545 response, ok := out.RawResponse.(*smithyhttp.Response) 5546 if !ok { 5547 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5548 } 5549 5550 if response.StatusCode < 200 || response.StatusCode >= 300 { 5551 return out, metadata, awsRestjson1_deserializeOpErrorListClassificationJobs(response, &metadata) 5552 } 5553 output := &ListClassificationJobsOutput{} 5554 out.Result = output 5555 5556 var buff [1024]byte 5557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5558 5559 body := io.TeeReader(response.Body, ringBuffer) 5560 5561 decoder := json.NewDecoder(body) 5562 decoder.UseNumber() 5563 var shape interface{} 5564 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5565 var snapshot bytes.Buffer 5566 io.Copy(&snapshot, ringBuffer) 5567 err = &smithy.DeserializationError{ 5568 Err: fmt.Errorf("failed to decode response body, %w", err), 5569 Snapshot: snapshot.Bytes(), 5570 } 5571 return out, metadata, err 5572 } 5573 5574 err = awsRestjson1_deserializeOpDocumentListClassificationJobsOutput(&output, shape) 5575 if err != nil { 5576 var snapshot bytes.Buffer 5577 io.Copy(&snapshot, ringBuffer) 5578 return out, metadata, &smithy.DeserializationError{ 5579 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5580 Snapshot: snapshot.Bytes(), 5581 } 5582 } 5583 5584 return out, metadata, err 5585} 5586 5587func awsRestjson1_deserializeOpErrorListClassificationJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5588 var errorBuffer bytes.Buffer 5589 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5590 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5591 } 5592 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5593 5594 errorCode := "UnknownError" 5595 errorMessage := errorCode 5596 5597 code := response.Header.Get("X-Amzn-ErrorType") 5598 if len(code) != 0 { 5599 errorCode = restjson.SanitizeErrorCode(code) 5600 } 5601 5602 var buff [1024]byte 5603 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5604 5605 body := io.TeeReader(errorBody, ringBuffer) 5606 decoder := json.NewDecoder(body) 5607 decoder.UseNumber() 5608 code, message, err := restjson.GetErrorInfo(decoder) 5609 if err != nil { 5610 var snapshot bytes.Buffer 5611 io.Copy(&snapshot, ringBuffer) 5612 err = &smithy.DeserializationError{ 5613 Err: fmt.Errorf("failed to decode response body, %w", err), 5614 Snapshot: snapshot.Bytes(), 5615 } 5616 return err 5617 } 5618 5619 errorBody.Seek(0, io.SeekStart) 5620 if len(code) != 0 { 5621 errorCode = restjson.SanitizeErrorCode(code) 5622 } 5623 if len(message) != 0 { 5624 errorMessage = message 5625 } 5626 5627 switch { 5628 case strings.EqualFold("AccessDeniedException", errorCode): 5629 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5630 5631 case strings.EqualFold("ConflictException", errorCode): 5632 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5633 5634 case strings.EqualFold("InternalServerException", errorCode): 5635 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5636 5637 case strings.EqualFold("ResourceNotFoundException", errorCode): 5638 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5639 5640 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5641 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5642 5643 case strings.EqualFold("ThrottlingException", errorCode): 5644 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5645 5646 case strings.EqualFold("ValidationException", errorCode): 5647 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5648 5649 default: 5650 genericError := &smithy.GenericAPIError{ 5651 Code: errorCode, 5652 Message: errorMessage, 5653 } 5654 return genericError 5655 5656 } 5657} 5658 5659func awsRestjson1_deserializeOpDocumentListClassificationJobsOutput(v **ListClassificationJobsOutput, value interface{}) error { 5660 if v == nil { 5661 return fmt.Errorf("unexpected nil of type %T", v) 5662 } 5663 if value == nil { 5664 return nil 5665 } 5666 5667 shape, ok := value.(map[string]interface{}) 5668 if !ok { 5669 return fmt.Errorf("unexpected JSON type %v", value) 5670 } 5671 5672 var sv *ListClassificationJobsOutput 5673 if *v == nil { 5674 sv = &ListClassificationJobsOutput{} 5675 } else { 5676 sv = *v 5677 } 5678 5679 for key, value := range shape { 5680 switch key { 5681 case "items": 5682 if err := awsRestjson1_deserializeDocument__listOfJobSummary(&sv.Items, value); err != nil { 5683 return err 5684 } 5685 5686 case "nextToken": 5687 if value != nil { 5688 jtv, ok := value.(string) 5689 if !ok { 5690 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5691 } 5692 sv.NextToken = ptr.String(jtv) 5693 } 5694 5695 default: 5696 _, _ = key, value 5697 5698 } 5699 } 5700 *v = sv 5701 return nil 5702} 5703 5704type awsRestjson1_deserializeOpListCustomDataIdentifiers struct { 5705} 5706 5707func (*awsRestjson1_deserializeOpListCustomDataIdentifiers) ID() string { 5708 return "OperationDeserializer" 5709} 5710 5711func (m *awsRestjson1_deserializeOpListCustomDataIdentifiers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5712 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5713) { 5714 out, metadata, err = next.HandleDeserialize(ctx, in) 5715 if err != nil { 5716 return out, metadata, err 5717 } 5718 5719 response, ok := out.RawResponse.(*smithyhttp.Response) 5720 if !ok { 5721 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5722 } 5723 5724 if response.StatusCode < 200 || response.StatusCode >= 300 { 5725 return out, metadata, awsRestjson1_deserializeOpErrorListCustomDataIdentifiers(response, &metadata) 5726 } 5727 output := &ListCustomDataIdentifiersOutput{} 5728 out.Result = output 5729 5730 var buff [1024]byte 5731 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5732 5733 body := io.TeeReader(response.Body, ringBuffer) 5734 5735 decoder := json.NewDecoder(body) 5736 decoder.UseNumber() 5737 var shape interface{} 5738 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5739 var snapshot bytes.Buffer 5740 io.Copy(&snapshot, ringBuffer) 5741 err = &smithy.DeserializationError{ 5742 Err: fmt.Errorf("failed to decode response body, %w", err), 5743 Snapshot: snapshot.Bytes(), 5744 } 5745 return out, metadata, err 5746 } 5747 5748 err = awsRestjson1_deserializeOpDocumentListCustomDataIdentifiersOutput(&output, shape) 5749 if err != nil { 5750 var snapshot bytes.Buffer 5751 io.Copy(&snapshot, ringBuffer) 5752 return out, metadata, &smithy.DeserializationError{ 5753 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5754 Snapshot: snapshot.Bytes(), 5755 } 5756 } 5757 5758 return out, metadata, err 5759} 5760 5761func awsRestjson1_deserializeOpErrorListCustomDataIdentifiers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5762 var errorBuffer bytes.Buffer 5763 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5764 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5765 } 5766 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5767 5768 errorCode := "UnknownError" 5769 errorMessage := errorCode 5770 5771 code := response.Header.Get("X-Amzn-ErrorType") 5772 if len(code) != 0 { 5773 errorCode = restjson.SanitizeErrorCode(code) 5774 } 5775 5776 var buff [1024]byte 5777 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5778 5779 body := io.TeeReader(errorBody, ringBuffer) 5780 decoder := json.NewDecoder(body) 5781 decoder.UseNumber() 5782 code, message, err := restjson.GetErrorInfo(decoder) 5783 if err != nil { 5784 var snapshot bytes.Buffer 5785 io.Copy(&snapshot, ringBuffer) 5786 err = &smithy.DeserializationError{ 5787 Err: fmt.Errorf("failed to decode response body, %w", err), 5788 Snapshot: snapshot.Bytes(), 5789 } 5790 return err 5791 } 5792 5793 errorBody.Seek(0, io.SeekStart) 5794 if len(code) != 0 { 5795 errorCode = restjson.SanitizeErrorCode(code) 5796 } 5797 if len(message) != 0 { 5798 errorMessage = message 5799 } 5800 5801 switch { 5802 case strings.EqualFold("AccessDeniedException", errorCode): 5803 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5804 5805 case strings.EqualFold("ConflictException", errorCode): 5806 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5807 5808 case strings.EqualFold("InternalServerException", errorCode): 5809 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5810 5811 case strings.EqualFold("ResourceNotFoundException", errorCode): 5812 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5813 5814 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5815 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5816 5817 case strings.EqualFold("ThrottlingException", errorCode): 5818 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5819 5820 case strings.EqualFold("ValidationException", errorCode): 5821 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5822 5823 default: 5824 genericError := &smithy.GenericAPIError{ 5825 Code: errorCode, 5826 Message: errorMessage, 5827 } 5828 return genericError 5829 5830 } 5831} 5832 5833func awsRestjson1_deserializeOpDocumentListCustomDataIdentifiersOutput(v **ListCustomDataIdentifiersOutput, value interface{}) error { 5834 if v == nil { 5835 return fmt.Errorf("unexpected nil of type %T", v) 5836 } 5837 if value == nil { 5838 return nil 5839 } 5840 5841 shape, ok := value.(map[string]interface{}) 5842 if !ok { 5843 return fmt.Errorf("unexpected JSON type %v", value) 5844 } 5845 5846 var sv *ListCustomDataIdentifiersOutput 5847 if *v == nil { 5848 sv = &ListCustomDataIdentifiersOutput{} 5849 } else { 5850 sv = *v 5851 } 5852 5853 for key, value := range shape { 5854 switch key { 5855 case "items": 5856 if err := awsRestjson1_deserializeDocument__listOfCustomDataIdentifierSummary(&sv.Items, value); err != nil { 5857 return err 5858 } 5859 5860 case "nextToken": 5861 if value != nil { 5862 jtv, ok := value.(string) 5863 if !ok { 5864 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5865 } 5866 sv.NextToken = ptr.String(jtv) 5867 } 5868 5869 default: 5870 _, _ = key, value 5871 5872 } 5873 } 5874 *v = sv 5875 return nil 5876} 5877 5878type awsRestjson1_deserializeOpListFindings struct { 5879} 5880 5881func (*awsRestjson1_deserializeOpListFindings) ID() string { 5882 return "OperationDeserializer" 5883} 5884 5885func (m *awsRestjson1_deserializeOpListFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5886 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5887) { 5888 out, metadata, err = next.HandleDeserialize(ctx, in) 5889 if err != nil { 5890 return out, metadata, err 5891 } 5892 5893 response, ok := out.RawResponse.(*smithyhttp.Response) 5894 if !ok { 5895 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5896 } 5897 5898 if response.StatusCode < 200 || response.StatusCode >= 300 { 5899 return out, metadata, awsRestjson1_deserializeOpErrorListFindings(response, &metadata) 5900 } 5901 output := &ListFindingsOutput{} 5902 out.Result = output 5903 5904 var buff [1024]byte 5905 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5906 5907 body := io.TeeReader(response.Body, ringBuffer) 5908 5909 decoder := json.NewDecoder(body) 5910 decoder.UseNumber() 5911 var shape interface{} 5912 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5913 var snapshot bytes.Buffer 5914 io.Copy(&snapshot, ringBuffer) 5915 err = &smithy.DeserializationError{ 5916 Err: fmt.Errorf("failed to decode response body, %w", err), 5917 Snapshot: snapshot.Bytes(), 5918 } 5919 return out, metadata, err 5920 } 5921 5922 err = awsRestjson1_deserializeOpDocumentListFindingsOutput(&output, shape) 5923 if err != nil { 5924 var snapshot bytes.Buffer 5925 io.Copy(&snapshot, ringBuffer) 5926 return out, metadata, &smithy.DeserializationError{ 5927 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5928 Snapshot: snapshot.Bytes(), 5929 } 5930 } 5931 5932 return out, metadata, err 5933} 5934 5935func awsRestjson1_deserializeOpErrorListFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5936 var errorBuffer bytes.Buffer 5937 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5938 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5939 } 5940 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5941 5942 errorCode := "UnknownError" 5943 errorMessage := errorCode 5944 5945 code := response.Header.Get("X-Amzn-ErrorType") 5946 if len(code) != 0 { 5947 errorCode = restjson.SanitizeErrorCode(code) 5948 } 5949 5950 var buff [1024]byte 5951 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5952 5953 body := io.TeeReader(errorBody, ringBuffer) 5954 decoder := json.NewDecoder(body) 5955 decoder.UseNumber() 5956 code, message, err := restjson.GetErrorInfo(decoder) 5957 if err != nil { 5958 var snapshot bytes.Buffer 5959 io.Copy(&snapshot, ringBuffer) 5960 err = &smithy.DeserializationError{ 5961 Err: fmt.Errorf("failed to decode response body, %w", err), 5962 Snapshot: snapshot.Bytes(), 5963 } 5964 return err 5965 } 5966 5967 errorBody.Seek(0, io.SeekStart) 5968 if len(code) != 0 { 5969 errorCode = restjson.SanitizeErrorCode(code) 5970 } 5971 if len(message) != 0 { 5972 errorMessage = message 5973 } 5974 5975 switch { 5976 case strings.EqualFold("AccessDeniedException", errorCode): 5977 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5978 5979 case strings.EqualFold("ConflictException", errorCode): 5980 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5981 5982 case strings.EqualFold("InternalServerException", errorCode): 5983 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5984 5985 case strings.EqualFold("ResourceNotFoundException", errorCode): 5986 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5987 5988 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5989 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5990 5991 case strings.EqualFold("ThrottlingException", errorCode): 5992 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5993 5994 case strings.EqualFold("ValidationException", errorCode): 5995 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5996 5997 default: 5998 genericError := &smithy.GenericAPIError{ 5999 Code: errorCode, 6000 Message: errorMessage, 6001 } 6002 return genericError 6003 6004 } 6005} 6006 6007func awsRestjson1_deserializeOpDocumentListFindingsOutput(v **ListFindingsOutput, value interface{}) error { 6008 if v == nil { 6009 return fmt.Errorf("unexpected nil of type %T", v) 6010 } 6011 if value == nil { 6012 return nil 6013 } 6014 6015 shape, ok := value.(map[string]interface{}) 6016 if !ok { 6017 return fmt.Errorf("unexpected JSON type %v", value) 6018 } 6019 6020 var sv *ListFindingsOutput 6021 if *v == nil { 6022 sv = &ListFindingsOutput{} 6023 } else { 6024 sv = *v 6025 } 6026 6027 for key, value := range shape { 6028 switch key { 6029 case "findingIds": 6030 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.FindingIds, value); err != nil { 6031 return err 6032 } 6033 6034 case "nextToken": 6035 if value != nil { 6036 jtv, ok := value.(string) 6037 if !ok { 6038 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6039 } 6040 sv.NextToken = ptr.String(jtv) 6041 } 6042 6043 default: 6044 _, _ = key, value 6045 6046 } 6047 } 6048 *v = sv 6049 return nil 6050} 6051 6052type awsRestjson1_deserializeOpListFindingsFilters struct { 6053} 6054 6055func (*awsRestjson1_deserializeOpListFindingsFilters) ID() string { 6056 return "OperationDeserializer" 6057} 6058 6059func (m *awsRestjson1_deserializeOpListFindingsFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6060 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6061) { 6062 out, metadata, err = next.HandleDeserialize(ctx, in) 6063 if err != nil { 6064 return out, metadata, err 6065 } 6066 6067 response, ok := out.RawResponse.(*smithyhttp.Response) 6068 if !ok { 6069 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6070 } 6071 6072 if response.StatusCode < 200 || response.StatusCode >= 300 { 6073 return out, metadata, awsRestjson1_deserializeOpErrorListFindingsFilters(response, &metadata) 6074 } 6075 output := &ListFindingsFiltersOutput{} 6076 out.Result = output 6077 6078 var buff [1024]byte 6079 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6080 6081 body := io.TeeReader(response.Body, ringBuffer) 6082 6083 decoder := json.NewDecoder(body) 6084 decoder.UseNumber() 6085 var shape interface{} 6086 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6087 var snapshot bytes.Buffer 6088 io.Copy(&snapshot, ringBuffer) 6089 err = &smithy.DeserializationError{ 6090 Err: fmt.Errorf("failed to decode response body, %w", err), 6091 Snapshot: snapshot.Bytes(), 6092 } 6093 return out, metadata, err 6094 } 6095 6096 err = awsRestjson1_deserializeOpDocumentListFindingsFiltersOutput(&output, shape) 6097 if err != nil { 6098 var snapshot bytes.Buffer 6099 io.Copy(&snapshot, ringBuffer) 6100 return out, metadata, &smithy.DeserializationError{ 6101 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6102 Snapshot: snapshot.Bytes(), 6103 } 6104 } 6105 6106 return out, metadata, err 6107} 6108 6109func awsRestjson1_deserializeOpErrorListFindingsFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6110 var errorBuffer bytes.Buffer 6111 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6112 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6113 } 6114 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6115 6116 errorCode := "UnknownError" 6117 errorMessage := errorCode 6118 6119 code := response.Header.Get("X-Amzn-ErrorType") 6120 if len(code) != 0 { 6121 errorCode = restjson.SanitizeErrorCode(code) 6122 } 6123 6124 var buff [1024]byte 6125 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6126 6127 body := io.TeeReader(errorBody, ringBuffer) 6128 decoder := json.NewDecoder(body) 6129 decoder.UseNumber() 6130 code, message, err := restjson.GetErrorInfo(decoder) 6131 if err != nil { 6132 var snapshot bytes.Buffer 6133 io.Copy(&snapshot, ringBuffer) 6134 err = &smithy.DeserializationError{ 6135 Err: fmt.Errorf("failed to decode response body, %w", err), 6136 Snapshot: snapshot.Bytes(), 6137 } 6138 return err 6139 } 6140 6141 errorBody.Seek(0, io.SeekStart) 6142 if len(code) != 0 { 6143 errorCode = restjson.SanitizeErrorCode(code) 6144 } 6145 if len(message) != 0 { 6146 errorMessage = message 6147 } 6148 6149 switch { 6150 case strings.EqualFold("AccessDeniedException", errorCode): 6151 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6152 6153 case strings.EqualFold("ConflictException", errorCode): 6154 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6155 6156 case strings.EqualFold("InternalServerException", errorCode): 6157 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6158 6159 case strings.EqualFold("ResourceNotFoundException", errorCode): 6160 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6161 6162 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6163 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6164 6165 case strings.EqualFold("ThrottlingException", errorCode): 6166 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6167 6168 case strings.EqualFold("ValidationException", errorCode): 6169 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6170 6171 default: 6172 genericError := &smithy.GenericAPIError{ 6173 Code: errorCode, 6174 Message: errorMessage, 6175 } 6176 return genericError 6177 6178 } 6179} 6180 6181func awsRestjson1_deserializeOpDocumentListFindingsFiltersOutput(v **ListFindingsFiltersOutput, 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 *ListFindingsFiltersOutput 6195 if *v == nil { 6196 sv = &ListFindingsFiltersOutput{} 6197 } else { 6198 sv = *v 6199 } 6200 6201 for key, value := range shape { 6202 switch key { 6203 case "findingsFilterListItems": 6204 if err := awsRestjson1_deserializeDocument__listOfFindingsFilterListItem(&sv.FindingsFilterListItems, value); err != nil { 6205 return err 6206 } 6207 6208 case "nextToken": 6209 if value != nil { 6210 jtv, ok := value.(string) 6211 if !ok { 6212 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6213 } 6214 sv.NextToken = ptr.String(jtv) 6215 } 6216 6217 default: 6218 _, _ = key, value 6219 6220 } 6221 } 6222 *v = sv 6223 return nil 6224} 6225 6226type awsRestjson1_deserializeOpListInvitations struct { 6227} 6228 6229func (*awsRestjson1_deserializeOpListInvitations) ID() string { 6230 return "OperationDeserializer" 6231} 6232 6233func (m *awsRestjson1_deserializeOpListInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6234 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6235) { 6236 out, metadata, err = next.HandleDeserialize(ctx, in) 6237 if err != nil { 6238 return out, metadata, err 6239 } 6240 6241 response, ok := out.RawResponse.(*smithyhttp.Response) 6242 if !ok { 6243 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6244 } 6245 6246 if response.StatusCode < 200 || response.StatusCode >= 300 { 6247 return out, metadata, awsRestjson1_deserializeOpErrorListInvitations(response, &metadata) 6248 } 6249 output := &ListInvitationsOutput{} 6250 out.Result = output 6251 6252 var buff [1024]byte 6253 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6254 6255 body := io.TeeReader(response.Body, ringBuffer) 6256 6257 decoder := json.NewDecoder(body) 6258 decoder.UseNumber() 6259 var shape interface{} 6260 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6261 var snapshot bytes.Buffer 6262 io.Copy(&snapshot, ringBuffer) 6263 err = &smithy.DeserializationError{ 6264 Err: fmt.Errorf("failed to decode response body, %w", err), 6265 Snapshot: snapshot.Bytes(), 6266 } 6267 return out, metadata, err 6268 } 6269 6270 err = awsRestjson1_deserializeOpDocumentListInvitationsOutput(&output, shape) 6271 if err != nil { 6272 var snapshot bytes.Buffer 6273 io.Copy(&snapshot, ringBuffer) 6274 return out, metadata, &smithy.DeserializationError{ 6275 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6276 Snapshot: snapshot.Bytes(), 6277 } 6278 } 6279 6280 return out, metadata, err 6281} 6282 6283func awsRestjson1_deserializeOpErrorListInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6284 var errorBuffer bytes.Buffer 6285 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6286 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6287 } 6288 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6289 6290 errorCode := "UnknownError" 6291 errorMessage := errorCode 6292 6293 code := response.Header.Get("X-Amzn-ErrorType") 6294 if len(code) != 0 { 6295 errorCode = restjson.SanitizeErrorCode(code) 6296 } 6297 6298 var buff [1024]byte 6299 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6300 6301 body := io.TeeReader(errorBody, ringBuffer) 6302 decoder := json.NewDecoder(body) 6303 decoder.UseNumber() 6304 code, message, err := restjson.GetErrorInfo(decoder) 6305 if err != nil { 6306 var snapshot bytes.Buffer 6307 io.Copy(&snapshot, ringBuffer) 6308 err = &smithy.DeserializationError{ 6309 Err: fmt.Errorf("failed to decode response body, %w", err), 6310 Snapshot: snapshot.Bytes(), 6311 } 6312 return err 6313 } 6314 6315 errorBody.Seek(0, io.SeekStart) 6316 if len(code) != 0 { 6317 errorCode = restjson.SanitizeErrorCode(code) 6318 } 6319 if len(message) != 0 { 6320 errorMessage = message 6321 } 6322 6323 switch { 6324 case strings.EqualFold("AccessDeniedException", errorCode): 6325 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6326 6327 case strings.EqualFold("ConflictException", errorCode): 6328 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6329 6330 case strings.EqualFold("InternalServerException", errorCode): 6331 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6332 6333 case strings.EqualFold("ResourceNotFoundException", errorCode): 6334 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6335 6336 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6337 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6338 6339 case strings.EqualFold("ThrottlingException", errorCode): 6340 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6341 6342 case strings.EqualFold("ValidationException", errorCode): 6343 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6344 6345 default: 6346 genericError := &smithy.GenericAPIError{ 6347 Code: errorCode, 6348 Message: errorMessage, 6349 } 6350 return genericError 6351 6352 } 6353} 6354 6355func awsRestjson1_deserializeOpDocumentListInvitationsOutput(v **ListInvitationsOutput, value interface{}) error { 6356 if v == nil { 6357 return fmt.Errorf("unexpected nil of type %T", v) 6358 } 6359 if value == nil { 6360 return nil 6361 } 6362 6363 shape, ok := value.(map[string]interface{}) 6364 if !ok { 6365 return fmt.Errorf("unexpected JSON type %v", value) 6366 } 6367 6368 var sv *ListInvitationsOutput 6369 if *v == nil { 6370 sv = &ListInvitationsOutput{} 6371 } else { 6372 sv = *v 6373 } 6374 6375 for key, value := range shape { 6376 switch key { 6377 case "invitations": 6378 if err := awsRestjson1_deserializeDocument__listOfInvitation(&sv.Invitations, value); err != nil { 6379 return err 6380 } 6381 6382 case "nextToken": 6383 if value != nil { 6384 jtv, ok := value.(string) 6385 if !ok { 6386 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6387 } 6388 sv.NextToken = ptr.String(jtv) 6389 } 6390 6391 default: 6392 _, _ = key, value 6393 6394 } 6395 } 6396 *v = sv 6397 return nil 6398} 6399 6400type awsRestjson1_deserializeOpListMembers struct { 6401} 6402 6403func (*awsRestjson1_deserializeOpListMembers) ID() string { 6404 return "OperationDeserializer" 6405} 6406 6407func (m *awsRestjson1_deserializeOpListMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6408 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6409) { 6410 out, metadata, err = next.HandleDeserialize(ctx, in) 6411 if err != nil { 6412 return out, metadata, err 6413 } 6414 6415 response, ok := out.RawResponse.(*smithyhttp.Response) 6416 if !ok { 6417 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6418 } 6419 6420 if response.StatusCode < 200 || response.StatusCode >= 300 { 6421 return out, metadata, awsRestjson1_deserializeOpErrorListMembers(response, &metadata) 6422 } 6423 output := &ListMembersOutput{} 6424 out.Result = output 6425 6426 var buff [1024]byte 6427 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6428 6429 body := io.TeeReader(response.Body, ringBuffer) 6430 6431 decoder := json.NewDecoder(body) 6432 decoder.UseNumber() 6433 var shape interface{} 6434 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6435 var snapshot bytes.Buffer 6436 io.Copy(&snapshot, ringBuffer) 6437 err = &smithy.DeserializationError{ 6438 Err: fmt.Errorf("failed to decode response body, %w", err), 6439 Snapshot: snapshot.Bytes(), 6440 } 6441 return out, metadata, err 6442 } 6443 6444 err = awsRestjson1_deserializeOpDocumentListMembersOutput(&output, shape) 6445 if err != nil { 6446 var snapshot bytes.Buffer 6447 io.Copy(&snapshot, ringBuffer) 6448 return out, metadata, &smithy.DeserializationError{ 6449 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6450 Snapshot: snapshot.Bytes(), 6451 } 6452 } 6453 6454 return out, metadata, err 6455} 6456 6457func awsRestjson1_deserializeOpErrorListMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6458 var errorBuffer bytes.Buffer 6459 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6460 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6461 } 6462 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6463 6464 errorCode := "UnknownError" 6465 errorMessage := errorCode 6466 6467 code := response.Header.Get("X-Amzn-ErrorType") 6468 if len(code) != 0 { 6469 errorCode = restjson.SanitizeErrorCode(code) 6470 } 6471 6472 var buff [1024]byte 6473 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6474 6475 body := io.TeeReader(errorBody, ringBuffer) 6476 decoder := json.NewDecoder(body) 6477 decoder.UseNumber() 6478 code, message, err := restjson.GetErrorInfo(decoder) 6479 if err != nil { 6480 var snapshot bytes.Buffer 6481 io.Copy(&snapshot, ringBuffer) 6482 err = &smithy.DeserializationError{ 6483 Err: fmt.Errorf("failed to decode response body, %w", err), 6484 Snapshot: snapshot.Bytes(), 6485 } 6486 return err 6487 } 6488 6489 errorBody.Seek(0, io.SeekStart) 6490 if len(code) != 0 { 6491 errorCode = restjson.SanitizeErrorCode(code) 6492 } 6493 if len(message) != 0 { 6494 errorMessage = message 6495 } 6496 6497 switch { 6498 case strings.EqualFold("AccessDeniedException", errorCode): 6499 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6500 6501 case strings.EqualFold("ConflictException", errorCode): 6502 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6503 6504 case strings.EqualFold("InternalServerException", errorCode): 6505 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6506 6507 case strings.EqualFold("ResourceNotFoundException", errorCode): 6508 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6509 6510 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6511 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6512 6513 case strings.EqualFold("ThrottlingException", errorCode): 6514 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6515 6516 case strings.EqualFold("ValidationException", errorCode): 6517 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6518 6519 default: 6520 genericError := &smithy.GenericAPIError{ 6521 Code: errorCode, 6522 Message: errorMessage, 6523 } 6524 return genericError 6525 6526 } 6527} 6528 6529func awsRestjson1_deserializeOpDocumentListMembersOutput(v **ListMembersOutput, 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 sv *ListMembersOutput 6543 if *v == nil { 6544 sv = &ListMembersOutput{} 6545 } else { 6546 sv = *v 6547 } 6548 6549 for key, value := range shape { 6550 switch key { 6551 case "members": 6552 if err := awsRestjson1_deserializeDocument__listOfMember(&sv.Members, value); err != nil { 6553 return err 6554 } 6555 6556 case "nextToken": 6557 if value != nil { 6558 jtv, ok := value.(string) 6559 if !ok { 6560 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6561 } 6562 sv.NextToken = ptr.String(jtv) 6563 } 6564 6565 default: 6566 _, _ = key, value 6567 6568 } 6569 } 6570 *v = sv 6571 return nil 6572} 6573 6574type awsRestjson1_deserializeOpListOrganizationAdminAccounts struct { 6575} 6576 6577func (*awsRestjson1_deserializeOpListOrganizationAdminAccounts) ID() string { 6578 return "OperationDeserializer" 6579} 6580 6581func (m *awsRestjson1_deserializeOpListOrganizationAdminAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6582 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6583) { 6584 out, metadata, err = next.HandleDeserialize(ctx, in) 6585 if err != nil { 6586 return out, metadata, err 6587 } 6588 6589 response, ok := out.RawResponse.(*smithyhttp.Response) 6590 if !ok { 6591 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6592 } 6593 6594 if response.StatusCode < 200 || response.StatusCode >= 300 { 6595 return out, metadata, awsRestjson1_deserializeOpErrorListOrganizationAdminAccounts(response, &metadata) 6596 } 6597 output := &ListOrganizationAdminAccountsOutput{} 6598 out.Result = output 6599 6600 var buff [1024]byte 6601 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6602 6603 body := io.TeeReader(response.Body, ringBuffer) 6604 6605 decoder := json.NewDecoder(body) 6606 decoder.UseNumber() 6607 var shape interface{} 6608 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6609 var snapshot bytes.Buffer 6610 io.Copy(&snapshot, ringBuffer) 6611 err = &smithy.DeserializationError{ 6612 Err: fmt.Errorf("failed to decode response body, %w", err), 6613 Snapshot: snapshot.Bytes(), 6614 } 6615 return out, metadata, err 6616 } 6617 6618 err = awsRestjson1_deserializeOpDocumentListOrganizationAdminAccountsOutput(&output, shape) 6619 if err != nil { 6620 var snapshot bytes.Buffer 6621 io.Copy(&snapshot, ringBuffer) 6622 return out, metadata, &smithy.DeserializationError{ 6623 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6624 Snapshot: snapshot.Bytes(), 6625 } 6626 } 6627 6628 return out, metadata, err 6629} 6630 6631func awsRestjson1_deserializeOpErrorListOrganizationAdminAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6632 var errorBuffer bytes.Buffer 6633 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6634 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6635 } 6636 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6637 6638 errorCode := "UnknownError" 6639 errorMessage := errorCode 6640 6641 code := response.Header.Get("X-Amzn-ErrorType") 6642 if len(code) != 0 { 6643 errorCode = restjson.SanitizeErrorCode(code) 6644 } 6645 6646 var buff [1024]byte 6647 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6648 6649 body := io.TeeReader(errorBody, ringBuffer) 6650 decoder := json.NewDecoder(body) 6651 decoder.UseNumber() 6652 code, message, err := restjson.GetErrorInfo(decoder) 6653 if err != nil { 6654 var snapshot bytes.Buffer 6655 io.Copy(&snapshot, ringBuffer) 6656 err = &smithy.DeserializationError{ 6657 Err: fmt.Errorf("failed to decode response body, %w", err), 6658 Snapshot: snapshot.Bytes(), 6659 } 6660 return err 6661 } 6662 6663 errorBody.Seek(0, io.SeekStart) 6664 if len(code) != 0 { 6665 errorCode = restjson.SanitizeErrorCode(code) 6666 } 6667 if len(message) != 0 { 6668 errorMessage = message 6669 } 6670 6671 switch { 6672 case strings.EqualFold("AccessDeniedException", errorCode): 6673 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6674 6675 case strings.EqualFold("ConflictException", errorCode): 6676 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6677 6678 case strings.EqualFold("InternalServerException", errorCode): 6679 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6680 6681 case strings.EqualFold("ResourceNotFoundException", errorCode): 6682 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6683 6684 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6685 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6686 6687 case strings.EqualFold("ThrottlingException", errorCode): 6688 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6689 6690 case strings.EqualFold("ValidationException", errorCode): 6691 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6692 6693 default: 6694 genericError := &smithy.GenericAPIError{ 6695 Code: errorCode, 6696 Message: errorMessage, 6697 } 6698 return genericError 6699 6700 } 6701} 6702 6703func awsRestjson1_deserializeOpDocumentListOrganizationAdminAccountsOutput(v **ListOrganizationAdminAccountsOutput, value interface{}) error { 6704 if v == nil { 6705 return fmt.Errorf("unexpected nil of type %T", v) 6706 } 6707 if value == nil { 6708 return nil 6709 } 6710 6711 shape, ok := value.(map[string]interface{}) 6712 if !ok { 6713 return fmt.Errorf("unexpected JSON type %v", value) 6714 } 6715 6716 var sv *ListOrganizationAdminAccountsOutput 6717 if *v == nil { 6718 sv = &ListOrganizationAdminAccountsOutput{} 6719 } else { 6720 sv = *v 6721 } 6722 6723 for key, value := range shape { 6724 switch key { 6725 case "adminAccounts": 6726 if err := awsRestjson1_deserializeDocument__listOfAdminAccount(&sv.AdminAccounts, value); err != nil { 6727 return err 6728 } 6729 6730 case "nextToken": 6731 if value != nil { 6732 jtv, ok := value.(string) 6733 if !ok { 6734 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6735 } 6736 sv.NextToken = ptr.String(jtv) 6737 } 6738 6739 default: 6740 _, _ = key, value 6741 6742 } 6743 } 6744 *v = sv 6745 return nil 6746} 6747 6748type awsRestjson1_deserializeOpListTagsForResource struct { 6749} 6750 6751func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 6752 return "OperationDeserializer" 6753} 6754 6755func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6756 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6757) { 6758 out, metadata, err = next.HandleDeserialize(ctx, in) 6759 if err != nil { 6760 return out, metadata, err 6761 } 6762 6763 response, ok := out.RawResponse.(*smithyhttp.Response) 6764 if !ok { 6765 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6766 } 6767 6768 if response.StatusCode < 200 || response.StatusCode >= 300 { 6769 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 6770 } 6771 output := &ListTagsForResourceOutput{} 6772 out.Result = output 6773 6774 var buff [1024]byte 6775 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6776 6777 body := io.TeeReader(response.Body, ringBuffer) 6778 6779 decoder := json.NewDecoder(body) 6780 decoder.UseNumber() 6781 var shape interface{} 6782 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6783 var snapshot bytes.Buffer 6784 io.Copy(&snapshot, ringBuffer) 6785 err = &smithy.DeserializationError{ 6786 Err: fmt.Errorf("failed to decode response body, %w", err), 6787 Snapshot: snapshot.Bytes(), 6788 } 6789 return out, metadata, err 6790 } 6791 6792 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 6793 if err != nil { 6794 var snapshot bytes.Buffer 6795 io.Copy(&snapshot, ringBuffer) 6796 return out, metadata, &smithy.DeserializationError{ 6797 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6798 Snapshot: snapshot.Bytes(), 6799 } 6800 } 6801 6802 return out, metadata, err 6803} 6804 6805func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6806 var errorBuffer bytes.Buffer 6807 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6808 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6809 } 6810 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6811 6812 errorCode := "UnknownError" 6813 errorMessage := errorCode 6814 6815 code := response.Header.Get("X-Amzn-ErrorType") 6816 if len(code) != 0 { 6817 errorCode = restjson.SanitizeErrorCode(code) 6818 } 6819 6820 var buff [1024]byte 6821 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6822 6823 body := io.TeeReader(errorBody, ringBuffer) 6824 decoder := json.NewDecoder(body) 6825 decoder.UseNumber() 6826 code, message, err := restjson.GetErrorInfo(decoder) 6827 if err != nil { 6828 var snapshot bytes.Buffer 6829 io.Copy(&snapshot, ringBuffer) 6830 err = &smithy.DeserializationError{ 6831 Err: fmt.Errorf("failed to decode response body, %w", err), 6832 Snapshot: snapshot.Bytes(), 6833 } 6834 return err 6835 } 6836 6837 errorBody.Seek(0, io.SeekStart) 6838 if len(code) != 0 { 6839 errorCode = restjson.SanitizeErrorCode(code) 6840 } 6841 if len(message) != 0 { 6842 errorMessage = message 6843 } 6844 6845 switch { 6846 default: 6847 genericError := &smithy.GenericAPIError{ 6848 Code: errorCode, 6849 Message: errorMessage, 6850 } 6851 return genericError 6852 6853 } 6854} 6855 6856func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 6857 if v == nil { 6858 return fmt.Errorf("unexpected nil of type %T", v) 6859 } 6860 if value == nil { 6861 return nil 6862 } 6863 6864 shape, ok := value.(map[string]interface{}) 6865 if !ok { 6866 return fmt.Errorf("unexpected JSON type %v", value) 6867 } 6868 6869 var sv *ListTagsForResourceOutput 6870 if *v == nil { 6871 sv = &ListTagsForResourceOutput{} 6872 } else { 6873 sv = *v 6874 } 6875 6876 for key, value := range shape { 6877 switch key { 6878 case "tags": 6879 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 6880 return err 6881 } 6882 6883 default: 6884 _, _ = key, value 6885 6886 } 6887 } 6888 *v = sv 6889 return nil 6890} 6891 6892type awsRestjson1_deserializeOpPutClassificationExportConfiguration struct { 6893} 6894 6895func (*awsRestjson1_deserializeOpPutClassificationExportConfiguration) ID() string { 6896 return "OperationDeserializer" 6897} 6898 6899func (m *awsRestjson1_deserializeOpPutClassificationExportConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6900 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6901) { 6902 out, metadata, err = next.HandleDeserialize(ctx, in) 6903 if err != nil { 6904 return out, metadata, err 6905 } 6906 6907 response, ok := out.RawResponse.(*smithyhttp.Response) 6908 if !ok { 6909 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6910 } 6911 6912 if response.StatusCode < 200 || response.StatusCode >= 300 { 6913 return out, metadata, awsRestjson1_deserializeOpErrorPutClassificationExportConfiguration(response, &metadata) 6914 } 6915 output := &PutClassificationExportConfigurationOutput{} 6916 out.Result = output 6917 6918 var buff [1024]byte 6919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6920 6921 body := io.TeeReader(response.Body, ringBuffer) 6922 6923 decoder := json.NewDecoder(body) 6924 decoder.UseNumber() 6925 var shape interface{} 6926 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6927 var snapshot bytes.Buffer 6928 io.Copy(&snapshot, ringBuffer) 6929 err = &smithy.DeserializationError{ 6930 Err: fmt.Errorf("failed to decode response body, %w", err), 6931 Snapshot: snapshot.Bytes(), 6932 } 6933 return out, metadata, err 6934 } 6935 6936 err = awsRestjson1_deserializeOpDocumentPutClassificationExportConfigurationOutput(&output, shape) 6937 if err != nil { 6938 var snapshot bytes.Buffer 6939 io.Copy(&snapshot, ringBuffer) 6940 return out, metadata, &smithy.DeserializationError{ 6941 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6942 Snapshot: snapshot.Bytes(), 6943 } 6944 } 6945 6946 return out, metadata, err 6947} 6948 6949func awsRestjson1_deserializeOpErrorPutClassificationExportConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6950 var errorBuffer bytes.Buffer 6951 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6952 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6953 } 6954 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6955 6956 errorCode := "UnknownError" 6957 errorMessage := errorCode 6958 6959 code := response.Header.Get("X-Amzn-ErrorType") 6960 if len(code) != 0 { 6961 errorCode = restjson.SanitizeErrorCode(code) 6962 } 6963 6964 var buff [1024]byte 6965 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6966 6967 body := io.TeeReader(errorBody, ringBuffer) 6968 decoder := json.NewDecoder(body) 6969 decoder.UseNumber() 6970 code, message, err := restjson.GetErrorInfo(decoder) 6971 if err != nil { 6972 var snapshot bytes.Buffer 6973 io.Copy(&snapshot, ringBuffer) 6974 err = &smithy.DeserializationError{ 6975 Err: fmt.Errorf("failed to decode response body, %w", err), 6976 Snapshot: snapshot.Bytes(), 6977 } 6978 return err 6979 } 6980 6981 errorBody.Seek(0, io.SeekStart) 6982 if len(code) != 0 { 6983 errorCode = restjson.SanitizeErrorCode(code) 6984 } 6985 if len(message) != 0 { 6986 errorMessage = message 6987 } 6988 6989 switch { 6990 case strings.EqualFold("AccessDeniedException", errorCode): 6991 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6992 6993 case strings.EqualFold("ConflictException", errorCode): 6994 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6995 6996 case strings.EqualFold("InternalServerException", errorCode): 6997 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6998 6999 case strings.EqualFold("ResourceNotFoundException", errorCode): 7000 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7001 7002 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7003 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7004 7005 case strings.EqualFold("ThrottlingException", errorCode): 7006 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7007 7008 case strings.EqualFold("ValidationException", errorCode): 7009 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7010 7011 default: 7012 genericError := &smithy.GenericAPIError{ 7013 Code: errorCode, 7014 Message: errorMessage, 7015 } 7016 return genericError 7017 7018 } 7019} 7020 7021func awsRestjson1_deserializeOpDocumentPutClassificationExportConfigurationOutput(v **PutClassificationExportConfigurationOutput, value interface{}) error { 7022 if v == nil { 7023 return fmt.Errorf("unexpected nil of type %T", v) 7024 } 7025 if value == nil { 7026 return nil 7027 } 7028 7029 shape, ok := value.(map[string]interface{}) 7030 if !ok { 7031 return fmt.Errorf("unexpected JSON type %v", value) 7032 } 7033 7034 var sv *PutClassificationExportConfigurationOutput 7035 if *v == nil { 7036 sv = &PutClassificationExportConfigurationOutput{} 7037 } else { 7038 sv = *v 7039 } 7040 7041 for key, value := range shape { 7042 switch key { 7043 case "configuration": 7044 if err := awsRestjson1_deserializeDocumentClassificationExportConfiguration(&sv.Configuration, value); err != nil { 7045 return err 7046 } 7047 7048 default: 7049 _, _ = key, value 7050 7051 } 7052 } 7053 *v = sv 7054 return nil 7055} 7056 7057type awsRestjson1_deserializeOpTagResource struct { 7058} 7059 7060func (*awsRestjson1_deserializeOpTagResource) ID() string { 7061 return "OperationDeserializer" 7062} 7063 7064func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7065 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7066) { 7067 out, metadata, err = next.HandleDeserialize(ctx, in) 7068 if err != nil { 7069 return out, metadata, err 7070 } 7071 7072 response, ok := out.RawResponse.(*smithyhttp.Response) 7073 if !ok { 7074 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7075 } 7076 7077 if response.StatusCode < 200 || response.StatusCode >= 300 { 7078 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 7079 } 7080 output := &TagResourceOutput{} 7081 out.Result = output 7082 7083 return out, metadata, err 7084} 7085 7086func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7087 var errorBuffer bytes.Buffer 7088 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7089 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7090 } 7091 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7092 7093 errorCode := "UnknownError" 7094 errorMessage := errorCode 7095 7096 code := response.Header.Get("X-Amzn-ErrorType") 7097 if len(code) != 0 { 7098 errorCode = restjson.SanitizeErrorCode(code) 7099 } 7100 7101 var buff [1024]byte 7102 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7103 7104 body := io.TeeReader(errorBody, ringBuffer) 7105 decoder := json.NewDecoder(body) 7106 decoder.UseNumber() 7107 code, message, err := restjson.GetErrorInfo(decoder) 7108 if err != nil { 7109 var snapshot bytes.Buffer 7110 io.Copy(&snapshot, ringBuffer) 7111 err = &smithy.DeserializationError{ 7112 Err: fmt.Errorf("failed to decode response body, %w", err), 7113 Snapshot: snapshot.Bytes(), 7114 } 7115 return err 7116 } 7117 7118 errorBody.Seek(0, io.SeekStart) 7119 if len(code) != 0 { 7120 errorCode = restjson.SanitizeErrorCode(code) 7121 } 7122 if len(message) != 0 { 7123 errorMessage = message 7124 } 7125 7126 switch { 7127 default: 7128 genericError := &smithy.GenericAPIError{ 7129 Code: errorCode, 7130 Message: errorMessage, 7131 } 7132 return genericError 7133 7134 } 7135} 7136 7137type awsRestjson1_deserializeOpTestCustomDataIdentifier struct { 7138} 7139 7140func (*awsRestjson1_deserializeOpTestCustomDataIdentifier) ID() string { 7141 return "OperationDeserializer" 7142} 7143 7144func (m *awsRestjson1_deserializeOpTestCustomDataIdentifier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7145 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7146) { 7147 out, metadata, err = next.HandleDeserialize(ctx, in) 7148 if err != nil { 7149 return out, metadata, err 7150 } 7151 7152 response, ok := out.RawResponse.(*smithyhttp.Response) 7153 if !ok { 7154 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7155 } 7156 7157 if response.StatusCode < 200 || response.StatusCode >= 300 { 7158 return out, metadata, awsRestjson1_deserializeOpErrorTestCustomDataIdentifier(response, &metadata) 7159 } 7160 output := &TestCustomDataIdentifierOutput{} 7161 out.Result = output 7162 7163 var buff [1024]byte 7164 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7165 7166 body := io.TeeReader(response.Body, ringBuffer) 7167 7168 decoder := json.NewDecoder(body) 7169 decoder.UseNumber() 7170 var shape interface{} 7171 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7172 var snapshot bytes.Buffer 7173 io.Copy(&snapshot, ringBuffer) 7174 err = &smithy.DeserializationError{ 7175 Err: fmt.Errorf("failed to decode response body, %w", err), 7176 Snapshot: snapshot.Bytes(), 7177 } 7178 return out, metadata, err 7179 } 7180 7181 err = awsRestjson1_deserializeOpDocumentTestCustomDataIdentifierOutput(&output, shape) 7182 if err != nil { 7183 var snapshot bytes.Buffer 7184 io.Copy(&snapshot, ringBuffer) 7185 return out, metadata, &smithy.DeserializationError{ 7186 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7187 Snapshot: snapshot.Bytes(), 7188 } 7189 } 7190 7191 return out, metadata, err 7192} 7193 7194func awsRestjson1_deserializeOpErrorTestCustomDataIdentifier(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7195 var errorBuffer bytes.Buffer 7196 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7197 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7198 } 7199 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7200 7201 errorCode := "UnknownError" 7202 errorMessage := errorCode 7203 7204 code := response.Header.Get("X-Amzn-ErrorType") 7205 if len(code) != 0 { 7206 errorCode = restjson.SanitizeErrorCode(code) 7207 } 7208 7209 var buff [1024]byte 7210 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7211 7212 body := io.TeeReader(errorBody, ringBuffer) 7213 decoder := json.NewDecoder(body) 7214 decoder.UseNumber() 7215 code, message, err := restjson.GetErrorInfo(decoder) 7216 if err != nil { 7217 var snapshot bytes.Buffer 7218 io.Copy(&snapshot, ringBuffer) 7219 err = &smithy.DeserializationError{ 7220 Err: fmt.Errorf("failed to decode response body, %w", err), 7221 Snapshot: snapshot.Bytes(), 7222 } 7223 return err 7224 } 7225 7226 errorBody.Seek(0, io.SeekStart) 7227 if len(code) != 0 { 7228 errorCode = restjson.SanitizeErrorCode(code) 7229 } 7230 if len(message) != 0 { 7231 errorMessage = message 7232 } 7233 7234 switch { 7235 case strings.EqualFold("AccessDeniedException", errorCode): 7236 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7237 7238 case strings.EqualFold("ConflictException", errorCode): 7239 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7240 7241 case strings.EqualFold("InternalServerException", errorCode): 7242 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7243 7244 case strings.EqualFold("ResourceNotFoundException", errorCode): 7245 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7246 7247 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7248 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7249 7250 case strings.EqualFold("ThrottlingException", errorCode): 7251 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7252 7253 case strings.EqualFold("ValidationException", errorCode): 7254 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7255 7256 default: 7257 genericError := &smithy.GenericAPIError{ 7258 Code: errorCode, 7259 Message: errorMessage, 7260 } 7261 return genericError 7262 7263 } 7264} 7265 7266func awsRestjson1_deserializeOpDocumentTestCustomDataIdentifierOutput(v **TestCustomDataIdentifierOutput, value interface{}) error { 7267 if v == nil { 7268 return fmt.Errorf("unexpected nil of type %T", v) 7269 } 7270 if value == nil { 7271 return nil 7272 } 7273 7274 shape, ok := value.(map[string]interface{}) 7275 if !ok { 7276 return fmt.Errorf("unexpected JSON type %v", value) 7277 } 7278 7279 var sv *TestCustomDataIdentifierOutput 7280 if *v == nil { 7281 sv = &TestCustomDataIdentifierOutput{} 7282 } else { 7283 sv = *v 7284 } 7285 7286 for key, value := range shape { 7287 switch key { 7288 case "matchCount": 7289 if value != nil { 7290 jtv, ok := value.(json.Number) 7291 if !ok { 7292 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 7293 } 7294 i64, err := jtv.Int64() 7295 if err != nil { 7296 return err 7297 } 7298 sv.MatchCount = int32(i64) 7299 } 7300 7301 default: 7302 _, _ = key, value 7303 7304 } 7305 } 7306 *v = sv 7307 return nil 7308} 7309 7310type awsRestjson1_deserializeOpUntagResource struct { 7311} 7312 7313func (*awsRestjson1_deserializeOpUntagResource) ID() string { 7314 return "OperationDeserializer" 7315} 7316 7317func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7318 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7319) { 7320 out, metadata, err = next.HandleDeserialize(ctx, in) 7321 if err != nil { 7322 return out, metadata, err 7323 } 7324 7325 response, ok := out.RawResponse.(*smithyhttp.Response) 7326 if !ok { 7327 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7328 } 7329 7330 if response.StatusCode < 200 || response.StatusCode >= 300 { 7331 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 7332 } 7333 output := &UntagResourceOutput{} 7334 out.Result = output 7335 7336 return out, metadata, err 7337} 7338 7339func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7340 var errorBuffer bytes.Buffer 7341 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7342 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7343 } 7344 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7345 7346 errorCode := "UnknownError" 7347 errorMessage := errorCode 7348 7349 code := response.Header.Get("X-Amzn-ErrorType") 7350 if len(code) != 0 { 7351 errorCode = restjson.SanitizeErrorCode(code) 7352 } 7353 7354 var buff [1024]byte 7355 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7356 7357 body := io.TeeReader(errorBody, ringBuffer) 7358 decoder := json.NewDecoder(body) 7359 decoder.UseNumber() 7360 code, message, err := restjson.GetErrorInfo(decoder) 7361 if err != nil { 7362 var snapshot bytes.Buffer 7363 io.Copy(&snapshot, ringBuffer) 7364 err = &smithy.DeserializationError{ 7365 Err: fmt.Errorf("failed to decode response body, %w", err), 7366 Snapshot: snapshot.Bytes(), 7367 } 7368 return err 7369 } 7370 7371 errorBody.Seek(0, io.SeekStart) 7372 if len(code) != 0 { 7373 errorCode = restjson.SanitizeErrorCode(code) 7374 } 7375 if len(message) != 0 { 7376 errorMessage = message 7377 } 7378 7379 switch { 7380 default: 7381 genericError := &smithy.GenericAPIError{ 7382 Code: errorCode, 7383 Message: errorMessage, 7384 } 7385 return genericError 7386 7387 } 7388} 7389 7390type awsRestjson1_deserializeOpUpdateClassificationJob struct { 7391} 7392 7393func (*awsRestjson1_deserializeOpUpdateClassificationJob) ID() string { 7394 return "OperationDeserializer" 7395} 7396 7397func (m *awsRestjson1_deserializeOpUpdateClassificationJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7398 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7399) { 7400 out, metadata, err = next.HandleDeserialize(ctx, in) 7401 if err != nil { 7402 return out, metadata, err 7403 } 7404 7405 response, ok := out.RawResponse.(*smithyhttp.Response) 7406 if !ok { 7407 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7408 } 7409 7410 if response.StatusCode < 200 || response.StatusCode >= 300 { 7411 return out, metadata, awsRestjson1_deserializeOpErrorUpdateClassificationJob(response, &metadata) 7412 } 7413 output := &UpdateClassificationJobOutput{} 7414 out.Result = output 7415 7416 return out, metadata, err 7417} 7418 7419func awsRestjson1_deserializeOpErrorUpdateClassificationJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7420 var errorBuffer bytes.Buffer 7421 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7422 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7423 } 7424 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7425 7426 errorCode := "UnknownError" 7427 errorMessage := errorCode 7428 7429 code := response.Header.Get("X-Amzn-ErrorType") 7430 if len(code) != 0 { 7431 errorCode = restjson.SanitizeErrorCode(code) 7432 } 7433 7434 var buff [1024]byte 7435 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7436 7437 body := io.TeeReader(errorBody, ringBuffer) 7438 decoder := json.NewDecoder(body) 7439 decoder.UseNumber() 7440 code, message, err := restjson.GetErrorInfo(decoder) 7441 if err != nil { 7442 var snapshot bytes.Buffer 7443 io.Copy(&snapshot, ringBuffer) 7444 err = &smithy.DeserializationError{ 7445 Err: fmt.Errorf("failed to decode response body, %w", err), 7446 Snapshot: snapshot.Bytes(), 7447 } 7448 return err 7449 } 7450 7451 errorBody.Seek(0, io.SeekStart) 7452 if len(code) != 0 { 7453 errorCode = restjson.SanitizeErrorCode(code) 7454 } 7455 if len(message) != 0 { 7456 errorMessage = message 7457 } 7458 7459 switch { 7460 case strings.EqualFold("AccessDeniedException", errorCode): 7461 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7462 7463 case strings.EqualFold("ConflictException", errorCode): 7464 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7465 7466 case strings.EqualFold("InternalServerException", errorCode): 7467 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7468 7469 case strings.EqualFold("ResourceNotFoundException", errorCode): 7470 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7471 7472 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7473 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7474 7475 case strings.EqualFold("ThrottlingException", errorCode): 7476 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7477 7478 case strings.EqualFold("ValidationException", errorCode): 7479 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7480 7481 default: 7482 genericError := &smithy.GenericAPIError{ 7483 Code: errorCode, 7484 Message: errorMessage, 7485 } 7486 return genericError 7487 7488 } 7489} 7490 7491type awsRestjson1_deserializeOpUpdateFindingsFilter struct { 7492} 7493 7494func (*awsRestjson1_deserializeOpUpdateFindingsFilter) ID() string { 7495 return "OperationDeserializer" 7496} 7497 7498func (m *awsRestjson1_deserializeOpUpdateFindingsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7499 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7500) { 7501 out, metadata, err = next.HandleDeserialize(ctx, in) 7502 if err != nil { 7503 return out, metadata, err 7504 } 7505 7506 response, ok := out.RawResponse.(*smithyhttp.Response) 7507 if !ok { 7508 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7509 } 7510 7511 if response.StatusCode < 200 || response.StatusCode >= 300 { 7512 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFindingsFilter(response, &metadata) 7513 } 7514 output := &UpdateFindingsFilterOutput{} 7515 out.Result = output 7516 7517 var buff [1024]byte 7518 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7519 7520 body := io.TeeReader(response.Body, ringBuffer) 7521 7522 decoder := json.NewDecoder(body) 7523 decoder.UseNumber() 7524 var shape interface{} 7525 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7526 var snapshot bytes.Buffer 7527 io.Copy(&snapshot, ringBuffer) 7528 err = &smithy.DeserializationError{ 7529 Err: fmt.Errorf("failed to decode response body, %w", err), 7530 Snapshot: snapshot.Bytes(), 7531 } 7532 return out, metadata, err 7533 } 7534 7535 err = awsRestjson1_deserializeOpDocumentUpdateFindingsFilterOutput(&output, shape) 7536 if err != nil { 7537 var snapshot bytes.Buffer 7538 io.Copy(&snapshot, ringBuffer) 7539 return out, metadata, &smithy.DeserializationError{ 7540 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7541 Snapshot: snapshot.Bytes(), 7542 } 7543 } 7544 7545 return out, metadata, err 7546} 7547 7548func awsRestjson1_deserializeOpErrorUpdateFindingsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7549 var errorBuffer bytes.Buffer 7550 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7551 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7552 } 7553 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7554 7555 errorCode := "UnknownError" 7556 errorMessage := errorCode 7557 7558 code := response.Header.Get("X-Amzn-ErrorType") 7559 if len(code) != 0 { 7560 errorCode = restjson.SanitizeErrorCode(code) 7561 } 7562 7563 var buff [1024]byte 7564 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7565 7566 body := io.TeeReader(errorBody, ringBuffer) 7567 decoder := json.NewDecoder(body) 7568 decoder.UseNumber() 7569 code, message, err := restjson.GetErrorInfo(decoder) 7570 if err != nil { 7571 var snapshot bytes.Buffer 7572 io.Copy(&snapshot, ringBuffer) 7573 err = &smithy.DeserializationError{ 7574 Err: fmt.Errorf("failed to decode response body, %w", err), 7575 Snapshot: snapshot.Bytes(), 7576 } 7577 return err 7578 } 7579 7580 errorBody.Seek(0, io.SeekStart) 7581 if len(code) != 0 { 7582 errorCode = restjson.SanitizeErrorCode(code) 7583 } 7584 if len(message) != 0 { 7585 errorMessage = message 7586 } 7587 7588 switch { 7589 case strings.EqualFold("AccessDeniedException", errorCode): 7590 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7591 7592 case strings.EqualFold("ConflictException", errorCode): 7593 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7594 7595 case strings.EqualFold("InternalServerException", errorCode): 7596 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7597 7598 case strings.EqualFold("ResourceNotFoundException", errorCode): 7599 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7600 7601 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7602 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7603 7604 case strings.EqualFold("ThrottlingException", errorCode): 7605 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7606 7607 case strings.EqualFold("ValidationException", errorCode): 7608 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7609 7610 default: 7611 genericError := &smithy.GenericAPIError{ 7612 Code: errorCode, 7613 Message: errorMessage, 7614 } 7615 return genericError 7616 7617 } 7618} 7619 7620func awsRestjson1_deserializeOpDocumentUpdateFindingsFilterOutput(v **UpdateFindingsFilterOutput, value interface{}) error { 7621 if v == nil { 7622 return fmt.Errorf("unexpected nil of type %T", v) 7623 } 7624 if value == nil { 7625 return nil 7626 } 7627 7628 shape, ok := value.(map[string]interface{}) 7629 if !ok { 7630 return fmt.Errorf("unexpected JSON type %v", value) 7631 } 7632 7633 var sv *UpdateFindingsFilterOutput 7634 if *v == nil { 7635 sv = &UpdateFindingsFilterOutput{} 7636 } else { 7637 sv = *v 7638 } 7639 7640 for key, value := range shape { 7641 switch key { 7642 case "arn": 7643 if value != nil { 7644 jtv, ok := value.(string) 7645 if !ok { 7646 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7647 } 7648 sv.Arn = ptr.String(jtv) 7649 } 7650 7651 case "id": 7652 if value != nil { 7653 jtv, ok := value.(string) 7654 if !ok { 7655 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7656 } 7657 sv.Id = ptr.String(jtv) 7658 } 7659 7660 default: 7661 _, _ = key, value 7662 7663 } 7664 } 7665 *v = sv 7666 return nil 7667} 7668 7669type awsRestjson1_deserializeOpUpdateMacieSession struct { 7670} 7671 7672func (*awsRestjson1_deserializeOpUpdateMacieSession) ID() string { 7673 return "OperationDeserializer" 7674} 7675 7676func (m *awsRestjson1_deserializeOpUpdateMacieSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7677 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7678) { 7679 out, metadata, err = next.HandleDeserialize(ctx, in) 7680 if err != nil { 7681 return out, metadata, err 7682 } 7683 7684 response, ok := out.RawResponse.(*smithyhttp.Response) 7685 if !ok { 7686 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7687 } 7688 7689 if response.StatusCode < 200 || response.StatusCode >= 300 { 7690 return out, metadata, awsRestjson1_deserializeOpErrorUpdateMacieSession(response, &metadata) 7691 } 7692 output := &UpdateMacieSessionOutput{} 7693 out.Result = output 7694 7695 return out, metadata, err 7696} 7697 7698func awsRestjson1_deserializeOpErrorUpdateMacieSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7699 var errorBuffer bytes.Buffer 7700 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7701 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7702 } 7703 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7704 7705 errorCode := "UnknownError" 7706 errorMessage := errorCode 7707 7708 code := response.Header.Get("X-Amzn-ErrorType") 7709 if len(code) != 0 { 7710 errorCode = restjson.SanitizeErrorCode(code) 7711 } 7712 7713 var buff [1024]byte 7714 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7715 7716 body := io.TeeReader(errorBody, ringBuffer) 7717 decoder := json.NewDecoder(body) 7718 decoder.UseNumber() 7719 code, message, err := restjson.GetErrorInfo(decoder) 7720 if err != nil { 7721 var snapshot bytes.Buffer 7722 io.Copy(&snapshot, ringBuffer) 7723 err = &smithy.DeserializationError{ 7724 Err: fmt.Errorf("failed to decode response body, %w", err), 7725 Snapshot: snapshot.Bytes(), 7726 } 7727 return err 7728 } 7729 7730 errorBody.Seek(0, io.SeekStart) 7731 if len(code) != 0 { 7732 errorCode = restjson.SanitizeErrorCode(code) 7733 } 7734 if len(message) != 0 { 7735 errorMessage = message 7736 } 7737 7738 switch { 7739 case strings.EqualFold("AccessDeniedException", errorCode): 7740 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7741 7742 case strings.EqualFold("ConflictException", errorCode): 7743 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7744 7745 case strings.EqualFold("InternalServerException", errorCode): 7746 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7747 7748 case strings.EqualFold("ResourceNotFoundException", errorCode): 7749 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7750 7751 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7752 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7753 7754 case strings.EqualFold("ThrottlingException", errorCode): 7755 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7756 7757 case strings.EqualFold("ValidationException", errorCode): 7758 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7759 7760 default: 7761 genericError := &smithy.GenericAPIError{ 7762 Code: errorCode, 7763 Message: errorMessage, 7764 } 7765 return genericError 7766 7767 } 7768} 7769 7770type awsRestjson1_deserializeOpUpdateMemberSession struct { 7771} 7772 7773func (*awsRestjson1_deserializeOpUpdateMemberSession) ID() string { 7774 return "OperationDeserializer" 7775} 7776 7777func (m *awsRestjson1_deserializeOpUpdateMemberSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7778 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7779) { 7780 out, metadata, err = next.HandleDeserialize(ctx, in) 7781 if err != nil { 7782 return out, metadata, err 7783 } 7784 7785 response, ok := out.RawResponse.(*smithyhttp.Response) 7786 if !ok { 7787 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7788 } 7789 7790 if response.StatusCode < 200 || response.StatusCode >= 300 { 7791 return out, metadata, awsRestjson1_deserializeOpErrorUpdateMemberSession(response, &metadata) 7792 } 7793 output := &UpdateMemberSessionOutput{} 7794 out.Result = output 7795 7796 return out, metadata, err 7797} 7798 7799func awsRestjson1_deserializeOpErrorUpdateMemberSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7800 var errorBuffer bytes.Buffer 7801 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7802 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7803 } 7804 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7805 7806 errorCode := "UnknownError" 7807 errorMessage := errorCode 7808 7809 code := response.Header.Get("X-Amzn-ErrorType") 7810 if len(code) != 0 { 7811 errorCode = restjson.SanitizeErrorCode(code) 7812 } 7813 7814 var buff [1024]byte 7815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7816 7817 body := io.TeeReader(errorBody, ringBuffer) 7818 decoder := json.NewDecoder(body) 7819 decoder.UseNumber() 7820 code, message, err := restjson.GetErrorInfo(decoder) 7821 if err != nil { 7822 var snapshot bytes.Buffer 7823 io.Copy(&snapshot, ringBuffer) 7824 err = &smithy.DeserializationError{ 7825 Err: fmt.Errorf("failed to decode response body, %w", err), 7826 Snapshot: snapshot.Bytes(), 7827 } 7828 return err 7829 } 7830 7831 errorBody.Seek(0, io.SeekStart) 7832 if len(code) != 0 { 7833 errorCode = restjson.SanitizeErrorCode(code) 7834 } 7835 if len(message) != 0 { 7836 errorMessage = message 7837 } 7838 7839 switch { 7840 case strings.EqualFold("AccessDeniedException", errorCode): 7841 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7842 7843 case strings.EqualFold("ConflictException", errorCode): 7844 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7845 7846 case strings.EqualFold("InternalServerException", errorCode): 7847 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7848 7849 case strings.EqualFold("ResourceNotFoundException", errorCode): 7850 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7851 7852 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7853 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7854 7855 case strings.EqualFold("ThrottlingException", errorCode): 7856 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7857 7858 case strings.EqualFold("ValidationException", errorCode): 7859 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7860 7861 default: 7862 genericError := &smithy.GenericAPIError{ 7863 Code: errorCode, 7864 Message: errorMessage, 7865 } 7866 return genericError 7867 7868 } 7869} 7870 7871type awsRestjson1_deserializeOpUpdateOrganizationConfiguration struct { 7872} 7873 7874func (*awsRestjson1_deserializeOpUpdateOrganizationConfiguration) ID() string { 7875 return "OperationDeserializer" 7876} 7877 7878func (m *awsRestjson1_deserializeOpUpdateOrganizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7879 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7880) { 7881 out, metadata, err = next.HandleDeserialize(ctx, in) 7882 if err != nil { 7883 return out, metadata, err 7884 } 7885 7886 response, ok := out.RawResponse.(*smithyhttp.Response) 7887 if !ok { 7888 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7889 } 7890 7891 if response.StatusCode < 200 || response.StatusCode >= 300 { 7892 return out, metadata, awsRestjson1_deserializeOpErrorUpdateOrganizationConfiguration(response, &metadata) 7893 } 7894 output := &UpdateOrganizationConfigurationOutput{} 7895 out.Result = output 7896 7897 return out, metadata, err 7898} 7899 7900func awsRestjson1_deserializeOpErrorUpdateOrganizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7901 var errorBuffer bytes.Buffer 7902 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7903 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7904 } 7905 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7906 7907 errorCode := "UnknownError" 7908 errorMessage := errorCode 7909 7910 code := response.Header.Get("X-Amzn-ErrorType") 7911 if len(code) != 0 { 7912 errorCode = restjson.SanitizeErrorCode(code) 7913 } 7914 7915 var buff [1024]byte 7916 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7917 7918 body := io.TeeReader(errorBody, ringBuffer) 7919 decoder := json.NewDecoder(body) 7920 decoder.UseNumber() 7921 code, message, err := restjson.GetErrorInfo(decoder) 7922 if err != nil { 7923 var snapshot bytes.Buffer 7924 io.Copy(&snapshot, ringBuffer) 7925 err = &smithy.DeserializationError{ 7926 Err: fmt.Errorf("failed to decode response body, %w", err), 7927 Snapshot: snapshot.Bytes(), 7928 } 7929 return err 7930 } 7931 7932 errorBody.Seek(0, io.SeekStart) 7933 if len(code) != 0 { 7934 errorCode = restjson.SanitizeErrorCode(code) 7935 } 7936 if len(message) != 0 { 7937 errorMessage = message 7938 } 7939 7940 switch { 7941 case strings.EqualFold("AccessDeniedException", errorCode): 7942 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7943 7944 case strings.EqualFold("ConflictException", errorCode): 7945 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7946 7947 case strings.EqualFold("InternalServerException", errorCode): 7948 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7949 7950 case strings.EqualFold("ResourceNotFoundException", errorCode): 7951 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7952 7953 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7954 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7955 7956 case strings.EqualFold("ThrottlingException", errorCode): 7957 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7958 7959 case strings.EqualFold("ValidationException", errorCode): 7960 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7961 7962 default: 7963 genericError := &smithy.GenericAPIError{ 7964 Code: errorCode, 7965 Message: errorMessage, 7966 } 7967 return genericError 7968 7969 } 7970} 7971 7972func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7973 output := &types.AccessDeniedException{} 7974 var buff [1024]byte 7975 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7976 7977 body := io.TeeReader(errorBody, ringBuffer) 7978 decoder := json.NewDecoder(body) 7979 decoder.UseNumber() 7980 var shape interface{} 7981 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7982 var snapshot bytes.Buffer 7983 io.Copy(&snapshot, ringBuffer) 7984 err = &smithy.DeserializationError{ 7985 Err: fmt.Errorf("failed to decode response body, %w", err), 7986 Snapshot: snapshot.Bytes(), 7987 } 7988 return err 7989 } 7990 7991 err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape) 7992 7993 if err != nil { 7994 var snapshot bytes.Buffer 7995 io.Copy(&snapshot, ringBuffer) 7996 err = &smithy.DeserializationError{ 7997 Err: fmt.Errorf("failed to decode response body, %w", err), 7998 Snapshot: snapshot.Bytes(), 7999 } 8000 return err 8001 } 8002 8003 errorBody.Seek(0, io.SeekStart) 8004 8005 return output 8006} 8007 8008func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8009 output := &types.ConflictException{} 8010 var buff [1024]byte 8011 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8012 8013 body := io.TeeReader(errorBody, ringBuffer) 8014 decoder := json.NewDecoder(body) 8015 decoder.UseNumber() 8016 var shape interface{} 8017 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8018 var snapshot bytes.Buffer 8019 io.Copy(&snapshot, ringBuffer) 8020 err = &smithy.DeserializationError{ 8021 Err: fmt.Errorf("failed to decode response body, %w", err), 8022 Snapshot: snapshot.Bytes(), 8023 } 8024 return err 8025 } 8026 8027 err := awsRestjson1_deserializeDocumentConflictException(&output, shape) 8028 8029 if err != nil { 8030 var snapshot bytes.Buffer 8031 io.Copy(&snapshot, ringBuffer) 8032 err = &smithy.DeserializationError{ 8033 Err: fmt.Errorf("failed to decode response body, %w", err), 8034 Snapshot: snapshot.Bytes(), 8035 } 8036 return err 8037 } 8038 8039 errorBody.Seek(0, io.SeekStart) 8040 8041 return output 8042} 8043 8044func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8045 output := &types.InternalServerException{} 8046 var buff [1024]byte 8047 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8048 8049 body := io.TeeReader(errorBody, ringBuffer) 8050 decoder := json.NewDecoder(body) 8051 decoder.UseNumber() 8052 var shape interface{} 8053 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8054 var snapshot bytes.Buffer 8055 io.Copy(&snapshot, ringBuffer) 8056 err = &smithy.DeserializationError{ 8057 Err: fmt.Errorf("failed to decode response body, %w", err), 8058 Snapshot: snapshot.Bytes(), 8059 } 8060 return err 8061 } 8062 8063 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape) 8064 8065 if err != nil { 8066 var snapshot bytes.Buffer 8067 io.Copy(&snapshot, ringBuffer) 8068 err = &smithy.DeserializationError{ 8069 Err: fmt.Errorf("failed to decode response body, %w", err), 8070 Snapshot: snapshot.Bytes(), 8071 } 8072 return err 8073 } 8074 8075 errorBody.Seek(0, io.SeekStart) 8076 8077 return output 8078} 8079 8080func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8081 output := &types.ResourceNotFoundException{} 8082 var buff [1024]byte 8083 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8084 8085 body := io.TeeReader(errorBody, ringBuffer) 8086 decoder := json.NewDecoder(body) 8087 decoder.UseNumber() 8088 var shape interface{} 8089 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8090 var snapshot bytes.Buffer 8091 io.Copy(&snapshot, ringBuffer) 8092 err = &smithy.DeserializationError{ 8093 Err: fmt.Errorf("failed to decode response body, %w", err), 8094 Snapshot: snapshot.Bytes(), 8095 } 8096 return err 8097 } 8098 8099 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 8100 8101 if err != nil { 8102 var snapshot bytes.Buffer 8103 io.Copy(&snapshot, ringBuffer) 8104 err = &smithy.DeserializationError{ 8105 Err: fmt.Errorf("failed to decode response body, %w", err), 8106 Snapshot: snapshot.Bytes(), 8107 } 8108 return err 8109 } 8110 8111 errorBody.Seek(0, io.SeekStart) 8112 8113 return output 8114} 8115 8116func awsRestjson1_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8117 output := &types.ServiceQuotaExceededException{} 8118 var buff [1024]byte 8119 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8120 8121 body := io.TeeReader(errorBody, ringBuffer) 8122 decoder := json.NewDecoder(body) 8123 decoder.UseNumber() 8124 var shape interface{} 8125 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8126 var snapshot bytes.Buffer 8127 io.Copy(&snapshot, ringBuffer) 8128 err = &smithy.DeserializationError{ 8129 Err: fmt.Errorf("failed to decode response body, %w", err), 8130 Snapshot: snapshot.Bytes(), 8131 } 8132 return err 8133 } 8134 8135 err := awsRestjson1_deserializeDocumentServiceQuotaExceededException(&output, shape) 8136 8137 if err != nil { 8138 var snapshot bytes.Buffer 8139 io.Copy(&snapshot, ringBuffer) 8140 err = &smithy.DeserializationError{ 8141 Err: fmt.Errorf("failed to decode response body, %w", err), 8142 Snapshot: snapshot.Bytes(), 8143 } 8144 return err 8145 } 8146 8147 errorBody.Seek(0, io.SeekStart) 8148 8149 return output 8150} 8151 8152func awsRestjson1_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8153 output := &types.ThrottlingException{} 8154 var buff [1024]byte 8155 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8156 8157 body := io.TeeReader(errorBody, ringBuffer) 8158 decoder := json.NewDecoder(body) 8159 decoder.UseNumber() 8160 var shape interface{} 8161 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8162 var snapshot bytes.Buffer 8163 io.Copy(&snapshot, ringBuffer) 8164 err = &smithy.DeserializationError{ 8165 Err: fmt.Errorf("failed to decode response body, %w", err), 8166 Snapshot: snapshot.Bytes(), 8167 } 8168 return err 8169 } 8170 8171 err := awsRestjson1_deserializeDocumentThrottlingException(&output, shape) 8172 8173 if err != nil { 8174 var snapshot bytes.Buffer 8175 io.Copy(&snapshot, ringBuffer) 8176 err = &smithy.DeserializationError{ 8177 Err: fmt.Errorf("failed to decode response body, %w", err), 8178 Snapshot: snapshot.Bytes(), 8179 } 8180 return err 8181 } 8182 8183 errorBody.Seek(0, io.SeekStart) 8184 8185 return output 8186} 8187 8188func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8189 output := &types.ValidationException{} 8190 var buff [1024]byte 8191 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8192 8193 body := io.TeeReader(errorBody, ringBuffer) 8194 decoder := json.NewDecoder(body) 8195 decoder.UseNumber() 8196 var shape interface{} 8197 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8198 var snapshot bytes.Buffer 8199 io.Copy(&snapshot, ringBuffer) 8200 err = &smithy.DeserializationError{ 8201 Err: fmt.Errorf("failed to decode response body, %w", err), 8202 Snapshot: snapshot.Bytes(), 8203 } 8204 return err 8205 } 8206 8207 err := awsRestjson1_deserializeDocumentValidationException(&output, shape) 8208 8209 if err != nil { 8210 var snapshot bytes.Buffer 8211 io.Copy(&snapshot, ringBuffer) 8212 err = &smithy.DeserializationError{ 8213 Err: fmt.Errorf("failed to decode response body, %w", err), 8214 Snapshot: snapshot.Bytes(), 8215 } 8216 return err 8217 } 8218 8219 errorBody.Seek(0, io.SeekStart) 8220 8221 return output 8222} 8223 8224func awsRestjson1_deserializeDocument__listOf__string(v *[]string, value interface{}) error { 8225 if v == nil { 8226 return fmt.Errorf("unexpected nil of type %T", v) 8227 } 8228 if value == nil { 8229 return nil 8230 } 8231 8232 shape, ok := value.([]interface{}) 8233 if !ok { 8234 return fmt.Errorf("unexpected JSON type %v", value) 8235 } 8236 8237 var cv []string 8238 if *v == nil { 8239 cv = []string{} 8240 } else { 8241 cv = *v 8242 } 8243 8244 for _, value := range shape { 8245 var col string 8246 if value != nil { 8247 jtv, ok := value.(string) 8248 if !ok { 8249 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 8250 } 8251 col = jtv 8252 } 8253 cv = append(cv, col) 8254 8255 } 8256 *v = cv 8257 return nil 8258} 8259 8260func awsRestjson1_deserializeDocument__listOfAdminAccount(v *[]types.AdminAccount, value interface{}) error { 8261 if v == nil { 8262 return fmt.Errorf("unexpected nil of type %T", v) 8263 } 8264 if value == nil { 8265 return nil 8266 } 8267 8268 shape, ok := value.([]interface{}) 8269 if !ok { 8270 return fmt.Errorf("unexpected JSON type %v", value) 8271 } 8272 8273 var cv []types.AdminAccount 8274 if *v == nil { 8275 cv = []types.AdminAccount{} 8276 } else { 8277 cv = *v 8278 } 8279 8280 for _, value := range shape { 8281 var col types.AdminAccount 8282 destAddr := &col 8283 if err := awsRestjson1_deserializeDocumentAdminAccount(&destAddr, value); err != nil { 8284 return err 8285 } 8286 col = *destAddr 8287 cv = append(cv, col) 8288 8289 } 8290 *v = cv 8291 return nil 8292} 8293 8294func awsRestjson1_deserializeDocument__listOfBatchGetCustomDataIdentifierSummary(v *[]types.BatchGetCustomDataIdentifierSummary, value interface{}) error { 8295 if v == nil { 8296 return fmt.Errorf("unexpected nil of type %T", v) 8297 } 8298 if value == nil { 8299 return nil 8300 } 8301 8302 shape, ok := value.([]interface{}) 8303 if !ok { 8304 return fmt.Errorf("unexpected JSON type %v", value) 8305 } 8306 8307 var cv []types.BatchGetCustomDataIdentifierSummary 8308 if *v == nil { 8309 cv = []types.BatchGetCustomDataIdentifierSummary{} 8310 } else { 8311 cv = *v 8312 } 8313 8314 for _, value := range shape { 8315 var col types.BatchGetCustomDataIdentifierSummary 8316 destAddr := &col 8317 if err := awsRestjson1_deserializeDocumentBatchGetCustomDataIdentifierSummary(&destAddr, value); err != nil { 8318 return err 8319 } 8320 col = *destAddr 8321 cv = append(cv, col) 8322 8323 } 8324 *v = cv 8325 return nil 8326} 8327 8328func awsRestjson1_deserializeDocument__listOfBucketMetadata(v *[]types.BucketMetadata, value interface{}) error { 8329 if v == nil { 8330 return fmt.Errorf("unexpected nil of type %T", v) 8331 } 8332 if value == nil { 8333 return nil 8334 } 8335 8336 shape, ok := value.([]interface{}) 8337 if !ok { 8338 return fmt.Errorf("unexpected JSON type %v", value) 8339 } 8340 8341 var cv []types.BucketMetadata 8342 if *v == nil { 8343 cv = []types.BucketMetadata{} 8344 } else { 8345 cv = *v 8346 } 8347 8348 for _, value := range shape { 8349 var col types.BucketMetadata 8350 destAddr := &col 8351 if err := awsRestjson1_deserializeDocumentBucketMetadata(&destAddr, value); err != nil { 8352 return err 8353 } 8354 col = *destAddr 8355 cv = append(cv, col) 8356 8357 } 8358 *v = cv 8359 return nil 8360} 8361 8362func awsRestjson1_deserializeDocument__listOfCustomDataIdentifierSummary(v *[]types.CustomDataIdentifierSummary, value interface{}) error { 8363 if v == nil { 8364 return fmt.Errorf("unexpected nil of type %T", v) 8365 } 8366 if value == nil { 8367 return nil 8368 } 8369 8370 shape, ok := value.([]interface{}) 8371 if !ok { 8372 return fmt.Errorf("unexpected JSON type %v", value) 8373 } 8374 8375 var cv []types.CustomDataIdentifierSummary 8376 if *v == nil { 8377 cv = []types.CustomDataIdentifierSummary{} 8378 } else { 8379 cv = *v 8380 } 8381 8382 for _, value := range shape { 8383 var col types.CustomDataIdentifierSummary 8384 destAddr := &col 8385 if err := awsRestjson1_deserializeDocumentCustomDataIdentifierSummary(&destAddr, value); err != nil { 8386 return err 8387 } 8388 col = *destAddr 8389 cv = append(cv, col) 8390 8391 } 8392 *v = cv 8393 return nil 8394} 8395 8396func awsRestjson1_deserializeDocument__listOfFinding(v *[]types.Finding, value interface{}) error { 8397 if v == nil { 8398 return fmt.Errorf("unexpected nil of type %T", v) 8399 } 8400 if value == nil { 8401 return nil 8402 } 8403 8404 shape, ok := value.([]interface{}) 8405 if !ok { 8406 return fmt.Errorf("unexpected JSON type %v", value) 8407 } 8408 8409 var cv []types.Finding 8410 if *v == nil { 8411 cv = []types.Finding{} 8412 } else { 8413 cv = *v 8414 } 8415 8416 for _, value := range shape { 8417 var col types.Finding 8418 destAddr := &col 8419 if err := awsRestjson1_deserializeDocumentFinding(&destAddr, value); err != nil { 8420 return err 8421 } 8422 col = *destAddr 8423 cv = append(cv, col) 8424 8425 } 8426 *v = cv 8427 return nil 8428} 8429 8430func awsRestjson1_deserializeDocument__listOfFindingsFilterListItem(v *[]types.FindingsFilterListItem, value interface{}) error { 8431 if v == nil { 8432 return fmt.Errorf("unexpected nil of type %T", v) 8433 } 8434 if value == nil { 8435 return nil 8436 } 8437 8438 shape, ok := value.([]interface{}) 8439 if !ok { 8440 return fmt.Errorf("unexpected JSON type %v", value) 8441 } 8442 8443 var cv []types.FindingsFilterListItem 8444 if *v == nil { 8445 cv = []types.FindingsFilterListItem{} 8446 } else { 8447 cv = *v 8448 } 8449 8450 for _, value := range shape { 8451 var col types.FindingsFilterListItem 8452 destAddr := &col 8453 if err := awsRestjson1_deserializeDocumentFindingsFilterListItem(&destAddr, value); err != nil { 8454 return err 8455 } 8456 col = *destAddr 8457 cv = append(cv, col) 8458 8459 } 8460 *v = cv 8461 return nil 8462} 8463 8464func awsRestjson1_deserializeDocument__listOfGroupCount(v *[]types.GroupCount, value interface{}) error { 8465 if v == nil { 8466 return fmt.Errorf("unexpected nil of type %T", v) 8467 } 8468 if value == nil { 8469 return nil 8470 } 8471 8472 shape, ok := value.([]interface{}) 8473 if !ok { 8474 return fmt.Errorf("unexpected JSON type %v", value) 8475 } 8476 8477 var cv []types.GroupCount 8478 if *v == nil { 8479 cv = []types.GroupCount{} 8480 } else { 8481 cv = *v 8482 } 8483 8484 for _, value := range shape { 8485 var col types.GroupCount 8486 destAddr := &col 8487 if err := awsRestjson1_deserializeDocumentGroupCount(&destAddr, value); err != nil { 8488 return err 8489 } 8490 col = *destAddr 8491 cv = append(cv, col) 8492 8493 } 8494 *v = cv 8495 return nil 8496} 8497 8498func awsRestjson1_deserializeDocument__listOfInvitation(v *[]types.Invitation, value interface{}) error { 8499 if v == nil { 8500 return fmt.Errorf("unexpected nil of type %T", v) 8501 } 8502 if value == nil { 8503 return nil 8504 } 8505 8506 shape, ok := value.([]interface{}) 8507 if !ok { 8508 return fmt.Errorf("unexpected JSON type %v", value) 8509 } 8510 8511 var cv []types.Invitation 8512 if *v == nil { 8513 cv = []types.Invitation{} 8514 } else { 8515 cv = *v 8516 } 8517 8518 for _, value := range shape { 8519 var col types.Invitation 8520 destAddr := &col 8521 if err := awsRestjson1_deserializeDocumentInvitation(&destAddr, value); err != nil { 8522 return err 8523 } 8524 col = *destAddr 8525 cv = append(cv, col) 8526 8527 } 8528 *v = cv 8529 return nil 8530} 8531 8532func awsRestjson1_deserializeDocument__listOfJobScopeTerm(v *[]types.JobScopeTerm, value interface{}) error { 8533 if v == nil { 8534 return fmt.Errorf("unexpected nil of type %T", v) 8535 } 8536 if value == nil { 8537 return nil 8538 } 8539 8540 shape, ok := value.([]interface{}) 8541 if !ok { 8542 return fmt.Errorf("unexpected JSON type %v", value) 8543 } 8544 8545 var cv []types.JobScopeTerm 8546 if *v == nil { 8547 cv = []types.JobScopeTerm{} 8548 } else { 8549 cv = *v 8550 } 8551 8552 for _, value := range shape { 8553 var col types.JobScopeTerm 8554 destAddr := &col 8555 if err := awsRestjson1_deserializeDocumentJobScopeTerm(&destAddr, value); err != nil { 8556 return err 8557 } 8558 col = *destAddr 8559 cv = append(cv, col) 8560 8561 } 8562 *v = cv 8563 return nil 8564} 8565 8566func awsRestjson1_deserializeDocument__listOfJobSummary(v *[]types.JobSummary, value interface{}) error { 8567 if v == nil { 8568 return fmt.Errorf("unexpected nil of type %T", v) 8569 } 8570 if value == nil { 8571 return nil 8572 } 8573 8574 shape, ok := value.([]interface{}) 8575 if !ok { 8576 return fmt.Errorf("unexpected JSON type %v", value) 8577 } 8578 8579 var cv []types.JobSummary 8580 if *v == nil { 8581 cv = []types.JobSummary{} 8582 } else { 8583 cv = *v 8584 } 8585 8586 for _, value := range shape { 8587 var col types.JobSummary 8588 destAddr := &col 8589 if err := awsRestjson1_deserializeDocumentJobSummary(&destAddr, value); err != nil { 8590 return err 8591 } 8592 col = *destAddr 8593 cv = append(cv, col) 8594 8595 } 8596 *v = cv 8597 return nil 8598} 8599 8600func awsRestjson1_deserializeDocument__listOfKeyValuePair(v *[]types.KeyValuePair, value interface{}) error { 8601 if v == nil { 8602 return fmt.Errorf("unexpected nil of type %T", v) 8603 } 8604 if value == nil { 8605 return nil 8606 } 8607 8608 shape, ok := value.([]interface{}) 8609 if !ok { 8610 return fmt.Errorf("unexpected JSON type %v", value) 8611 } 8612 8613 var cv []types.KeyValuePair 8614 if *v == nil { 8615 cv = []types.KeyValuePair{} 8616 } else { 8617 cv = *v 8618 } 8619 8620 for _, value := range shape { 8621 var col types.KeyValuePair 8622 destAddr := &col 8623 if err := awsRestjson1_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 8624 return err 8625 } 8626 col = *destAddr 8627 cv = append(cv, col) 8628 8629 } 8630 *v = cv 8631 return nil 8632} 8633 8634func awsRestjson1_deserializeDocument__listOfMember(v *[]types.Member, value interface{}) error { 8635 if v == nil { 8636 return fmt.Errorf("unexpected nil of type %T", v) 8637 } 8638 if value == nil { 8639 return nil 8640 } 8641 8642 shape, ok := value.([]interface{}) 8643 if !ok { 8644 return fmt.Errorf("unexpected JSON type %v", value) 8645 } 8646 8647 var cv []types.Member 8648 if *v == nil { 8649 cv = []types.Member{} 8650 } else { 8651 cv = *v 8652 } 8653 8654 for _, value := range shape { 8655 var col types.Member 8656 destAddr := &col 8657 if err := awsRestjson1_deserializeDocumentMember(&destAddr, value); err != nil { 8658 return err 8659 } 8660 col = *destAddr 8661 cv = append(cv, col) 8662 8663 } 8664 *v = cv 8665 return nil 8666} 8667 8668func awsRestjson1_deserializeDocument__listOfS3BucketDefinitionForJob(v *[]types.S3BucketDefinitionForJob, value interface{}) error { 8669 if v == nil { 8670 return fmt.Errorf("unexpected nil of type %T", v) 8671 } 8672 if value == nil { 8673 return nil 8674 } 8675 8676 shape, ok := value.([]interface{}) 8677 if !ok { 8678 return fmt.Errorf("unexpected JSON type %v", value) 8679 } 8680 8681 var cv []types.S3BucketDefinitionForJob 8682 if *v == nil { 8683 cv = []types.S3BucketDefinitionForJob{} 8684 } else { 8685 cv = *v 8686 } 8687 8688 for _, value := range shape { 8689 var col types.S3BucketDefinitionForJob 8690 destAddr := &col 8691 if err := awsRestjson1_deserializeDocumentS3BucketDefinitionForJob(&destAddr, value); err != nil { 8692 return err 8693 } 8694 col = *destAddr 8695 cv = append(cv, col) 8696 8697 } 8698 *v = cv 8699 return nil 8700} 8701 8702func awsRestjson1_deserializeDocument__listOfTagValuePair(v *[]types.TagValuePair, value interface{}) error { 8703 if v == nil { 8704 return fmt.Errorf("unexpected nil of type %T", v) 8705 } 8706 if value == nil { 8707 return nil 8708 } 8709 8710 shape, ok := value.([]interface{}) 8711 if !ok { 8712 return fmt.Errorf("unexpected JSON type %v", value) 8713 } 8714 8715 var cv []types.TagValuePair 8716 if *v == nil { 8717 cv = []types.TagValuePair{} 8718 } else { 8719 cv = *v 8720 } 8721 8722 for _, value := range shape { 8723 var col types.TagValuePair 8724 destAddr := &col 8725 if err := awsRestjson1_deserializeDocumentTagValuePair(&destAddr, value); err != nil { 8726 return err 8727 } 8728 col = *destAddr 8729 cv = append(cv, col) 8730 8731 } 8732 *v = cv 8733 return nil 8734} 8735 8736func awsRestjson1_deserializeDocument__listOfUnprocessedAccount(v *[]types.UnprocessedAccount, value interface{}) error { 8737 if v == nil { 8738 return fmt.Errorf("unexpected nil of type %T", v) 8739 } 8740 if value == nil { 8741 return nil 8742 } 8743 8744 shape, ok := value.([]interface{}) 8745 if !ok { 8746 return fmt.Errorf("unexpected JSON type %v", value) 8747 } 8748 8749 var cv []types.UnprocessedAccount 8750 if *v == nil { 8751 cv = []types.UnprocessedAccount{} 8752 } else { 8753 cv = *v 8754 } 8755 8756 for _, value := range shape { 8757 var col types.UnprocessedAccount 8758 destAddr := &col 8759 if err := awsRestjson1_deserializeDocumentUnprocessedAccount(&destAddr, value); err != nil { 8760 return err 8761 } 8762 col = *destAddr 8763 cv = append(cv, col) 8764 8765 } 8766 *v = cv 8767 return nil 8768} 8769 8770func awsRestjson1_deserializeDocument__listOfUsageByAccount(v *[]types.UsageByAccount, value interface{}) error { 8771 if v == nil { 8772 return fmt.Errorf("unexpected nil of type %T", v) 8773 } 8774 if value == nil { 8775 return nil 8776 } 8777 8778 shape, ok := value.([]interface{}) 8779 if !ok { 8780 return fmt.Errorf("unexpected JSON type %v", value) 8781 } 8782 8783 var cv []types.UsageByAccount 8784 if *v == nil { 8785 cv = []types.UsageByAccount{} 8786 } else { 8787 cv = *v 8788 } 8789 8790 for _, value := range shape { 8791 var col types.UsageByAccount 8792 destAddr := &col 8793 if err := awsRestjson1_deserializeDocumentUsageByAccount(&destAddr, value); err != nil { 8794 return err 8795 } 8796 col = *destAddr 8797 cv = append(cv, col) 8798 8799 } 8800 *v = cv 8801 return nil 8802} 8803 8804func awsRestjson1_deserializeDocument__listOfUsageRecord(v *[]types.UsageRecord, value interface{}) error { 8805 if v == nil { 8806 return fmt.Errorf("unexpected nil of type %T", v) 8807 } 8808 if value == nil { 8809 return nil 8810 } 8811 8812 shape, ok := value.([]interface{}) 8813 if !ok { 8814 return fmt.Errorf("unexpected JSON type %v", value) 8815 } 8816 8817 var cv []types.UsageRecord 8818 if *v == nil { 8819 cv = []types.UsageRecord{} 8820 } else { 8821 cv = *v 8822 } 8823 8824 for _, value := range shape { 8825 var col types.UsageRecord 8826 destAddr := &col 8827 if err := awsRestjson1_deserializeDocumentUsageRecord(&destAddr, value); err != nil { 8828 return err 8829 } 8830 col = *destAddr 8831 cv = append(cv, col) 8832 8833 } 8834 *v = cv 8835 return nil 8836} 8837 8838func awsRestjson1_deserializeDocument__listOfUsageTotal(v *[]types.UsageTotal, value interface{}) error { 8839 if v == nil { 8840 return fmt.Errorf("unexpected nil of type %T", v) 8841 } 8842 if value == nil { 8843 return nil 8844 } 8845 8846 shape, ok := value.([]interface{}) 8847 if !ok { 8848 return fmt.Errorf("unexpected JSON type %v", value) 8849 } 8850 8851 var cv []types.UsageTotal 8852 if *v == nil { 8853 cv = []types.UsageTotal{} 8854 } else { 8855 cv = *v 8856 } 8857 8858 for _, value := range shape { 8859 var col types.UsageTotal 8860 destAddr := &col 8861 if err := awsRestjson1_deserializeDocumentUsageTotal(&destAddr, value); err != nil { 8862 return err 8863 } 8864 col = *destAddr 8865 cv = append(cv, col) 8866 8867 } 8868 *v = cv 8869 return nil 8870} 8871 8872func awsRestjson1_deserializeDocumentAccessControlList(v **types.AccessControlList, value interface{}) error { 8873 if v == nil { 8874 return fmt.Errorf("unexpected nil of type %T", v) 8875 } 8876 if value == nil { 8877 return nil 8878 } 8879 8880 shape, ok := value.(map[string]interface{}) 8881 if !ok { 8882 return fmt.Errorf("unexpected JSON type %v", value) 8883 } 8884 8885 var sv *types.AccessControlList 8886 if *v == nil { 8887 sv = &types.AccessControlList{} 8888 } else { 8889 sv = *v 8890 } 8891 8892 for key, value := range shape { 8893 switch key { 8894 case "allowsPublicReadAccess": 8895 if value != nil { 8896 jtv, ok := value.(bool) 8897 if !ok { 8898 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 8899 } 8900 sv.AllowsPublicReadAccess = jtv 8901 } 8902 8903 case "allowsPublicWriteAccess": 8904 if value != nil { 8905 jtv, ok := value.(bool) 8906 if !ok { 8907 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 8908 } 8909 sv.AllowsPublicWriteAccess = jtv 8910 } 8911 8912 default: 8913 _, _ = key, value 8914 8915 } 8916 } 8917 *v = sv 8918 return nil 8919} 8920 8921func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 8922 if v == nil { 8923 return fmt.Errorf("unexpected nil of type %T", v) 8924 } 8925 if value == nil { 8926 return nil 8927 } 8928 8929 shape, ok := value.(map[string]interface{}) 8930 if !ok { 8931 return fmt.Errorf("unexpected JSON type %v", value) 8932 } 8933 8934 var sv *types.AccessDeniedException 8935 if *v == nil { 8936 sv = &types.AccessDeniedException{} 8937 } else { 8938 sv = *v 8939 } 8940 8941 for key, value := range shape { 8942 switch key { 8943 case "message": 8944 if value != nil { 8945 jtv, ok := value.(string) 8946 if !ok { 8947 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 8948 } 8949 sv.Message = ptr.String(jtv) 8950 } 8951 8952 default: 8953 _, _ = key, value 8954 8955 } 8956 } 8957 *v = sv 8958 return nil 8959} 8960 8961func awsRestjson1_deserializeDocumentAccountLevelPermissions(v **types.AccountLevelPermissions, value interface{}) error { 8962 if v == nil { 8963 return fmt.Errorf("unexpected nil of type %T", v) 8964 } 8965 if value == nil { 8966 return nil 8967 } 8968 8969 shape, ok := value.(map[string]interface{}) 8970 if !ok { 8971 return fmt.Errorf("unexpected JSON type %v", value) 8972 } 8973 8974 var sv *types.AccountLevelPermissions 8975 if *v == nil { 8976 sv = &types.AccountLevelPermissions{} 8977 } else { 8978 sv = *v 8979 } 8980 8981 for key, value := range shape { 8982 switch key { 8983 case "blockPublicAccess": 8984 if err := awsRestjson1_deserializeDocumentBlockPublicAccess(&sv.BlockPublicAccess, value); err != nil { 8985 return err 8986 } 8987 8988 default: 8989 _, _ = key, value 8990 8991 } 8992 } 8993 *v = sv 8994 return nil 8995} 8996 8997func awsRestjson1_deserializeDocumentAdminAccount(v **types.AdminAccount, value interface{}) error { 8998 if v == nil { 8999 return fmt.Errorf("unexpected nil of type %T", v) 9000 } 9001 if value == nil { 9002 return nil 9003 } 9004 9005 shape, ok := value.(map[string]interface{}) 9006 if !ok { 9007 return fmt.Errorf("unexpected JSON type %v", value) 9008 } 9009 9010 var sv *types.AdminAccount 9011 if *v == nil { 9012 sv = &types.AdminAccount{} 9013 } else { 9014 sv = *v 9015 } 9016 9017 for key, value := range shape { 9018 switch key { 9019 case "accountId": 9020 if value != nil { 9021 jtv, ok := value.(string) 9022 if !ok { 9023 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9024 } 9025 sv.AccountId = ptr.String(jtv) 9026 } 9027 9028 case "status": 9029 if value != nil { 9030 jtv, ok := value.(string) 9031 if !ok { 9032 return fmt.Errorf("expected AdminStatus to be of type string, got %T instead", value) 9033 } 9034 sv.Status = types.AdminStatus(jtv) 9035 } 9036 9037 default: 9038 _, _ = key, value 9039 9040 } 9041 } 9042 *v = sv 9043 return nil 9044} 9045 9046func awsRestjson1_deserializeDocumentApiCallDetails(v **types.ApiCallDetails, value interface{}) error { 9047 if v == nil { 9048 return fmt.Errorf("unexpected nil of type %T", v) 9049 } 9050 if value == nil { 9051 return nil 9052 } 9053 9054 shape, ok := value.(map[string]interface{}) 9055 if !ok { 9056 return fmt.Errorf("unexpected JSON type %v", value) 9057 } 9058 9059 var sv *types.ApiCallDetails 9060 if *v == nil { 9061 sv = &types.ApiCallDetails{} 9062 } else { 9063 sv = *v 9064 } 9065 9066 for key, value := range shape { 9067 switch key { 9068 case "api": 9069 if value != nil { 9070 jtv, ok := value.(string) 9071 if !ok { 9072 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9073 } 9074 sv.Api = ptr.String(jtv) 9075 } 9076 9077 case "apiServiceName": 9078 if value != nil { 9079 jtv, ok := value.(string) 9080 if !ok { 9081 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9082 } 9083 sv.ApiServiceName = ptr.String(jtv) 9084 } 9085 9086 case "firstSeen": 9087 if value != nil { 9088 jtv, ok := value.(string) 9089 if !ok { 9090 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9091 } 9092 t, err := smithytime.ParseDateTime(jtv) 9093 if err != nil { 9094 return err 9095 } 9096 sv.FirstSeen = ptr.Time(t) 9097 } 9098 9099 case "lastSeen": 9100 if value != nil { 9101 jtv, ok := value.(string) 9102 if !ok { 9103 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9104 } 9105 t, err := smithytime.ParseDateTime(jtv) 9106 if err != nil { 9107 return err 9108 } 9109 sv.LastSeen = ptr.Time(t) 9110 } 9111 9112 default: 9113 _, _ = key, value 9114 9115 } 9116 } 9117 *v = sv 9118 return nil 9119} 9120 9121func awsRestjson1_deserializeDocumentAssumedRole(v **types.AssumedRole, value interface{}) error { 9122 if v == nil { 9123 return fmt.Errorf("unexpected nil of type %T", v) 9124 } 9125 if value == nil { 9126 return nil 9127 } 9128 9129 shape, ok := value.(map[string]interface{}) 9130 if !ok { 9131 return fmt.Errorf("unexpected JSON type %v", value) 9132 } 9133 9134 var sv *types.AssumedRole 9135 if *v == nil { 9136 sv = &types.AssumedRole{} 9137 } else { 9138 sv = *v 9139 } 9140 9141 for key, value := range shape { 9142 switch key { 9143 case "accessKeyId": 9144 if value != nil { 9145 jtv, ok := value.(string) 9146 if !ok { 9147 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9148 } 9149 sv.AccessKeyId = ptr.String(jtv) 9150 } 9151 9152 case "accountId": 9153 if value != nil { 9154 jtv, ok := value.(string) 9155 if !ok { 9156 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9157 } 9158 sv.AccountId = ptr.String(jtv) 9159 } 9160 9161 case "arn": 9162 if value != nil { 9163 jtv, ok := value.(string) 9164 if !ok { 9165 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9166 } 9167 sv.Arn = ptr.String(jtv) 9168 } 9169 9170 case "principalId": 9171 if value != nil { 9172 jtv, ok := value.(string) 9173 if !ok { 9174 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9175 } 9176 sv.PrincipalId = ptr.String(jtv) 9177 } 9178 9179 case "sessionContext": 9180 if err := awsRestjson1_deserializeDocumentSessionContext(&sv.SessionContext, value); err != nil { 9181 return err 9182 } 9183 9184 default: 9185 _, _ = key, value 9186 9187 } 9188 } 9189 *v = sv 9190 return nil 9191} 9192 9193func awsRestjson1_deserializeDocumentAwsAccount(v **types.AwsAccount, value interface{}) error { 9194 if v == nil { 9195 return fmt.Errorf("unexpected nil of type %T", v) 9196 } 9197 if value == nil { 9198 return nil 9199 } 9200 9201 shape, ok := value.(map[string]interface{}) 9202 if !ok { 9203 return fmt.Errorf("unexpected JSON type %v", value) 9204 } 9205 9206 var sv *types.AwsAccount 9207 if *v == nil { 9208 sv = &types.AwsAccount{} 9209 } else { 9210 sv = *v 9211 } 9212 9213 for key, value := range shape { 9214 switch key { 9215 case "accountId": 9216 if value != nil { 9217 jtv, ok := value.(string) 9218 if !ok { 9219 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9220 } 9221 sv.AccountId = ptr.String(jtv) 9222 } 9223 9224 case "principalId": 9225 if value != nil { 9226 jtv, ok := value.(string) 9227 if !ok { 9228 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9229 } 9230 sv.PrincipalId = ptr.String(jtv) 9231 } 9232 9233 default: 9234 _, _ = key, value 9235 9236 } 9237 } 9238 *v = sv 9239 return nil 9240} 9241 9242func awsRestjson1_deserializeDocumentAwsService(v **types.AwsService, value interface{}) error { 9243 if v == nil { 9244 return fmt.Errorf("unexpected nil of type %T", v) 9245 } 9246 if value == nil { 9247 return nil 9248 } 9249 9250 shape, ok := value.(map[string]interface{}) 9251 if !ok { 9252 return fmt.Errorf("unexpected JSON type %v", value) 9253 } 9254 9255 var sv *types.AwsService 9256 if *v == nil { 9257 sv = &types.AwsService{} 9258 } else { 9259 sv = *v 9260 } 9261 9262 for key, value := range shape { 9263 switch key { 9264 case "invokedBy": 9265 if value != nil { 9266 jtv, ok := value.(string) 9267 if !ok { 9268 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9269 } 9270 sv.InvokedBy = ptr.String(jtv) 9271 } 9272 9273 default: 9274 _, _ = key, value 9275 9276 } 9277 } 9278 *v = sv 9279 return nil 9280} 9281 9282func awsRestjson1_deserializeDocumentBatchGetCustomDataIdentifierSummary(v **types.BatchGetCustomDataIdentifierSummary, value interface{}) error { 9283 if v == nil { 9284 return fmt.Errorf("unexpected nil of type %T", v) 9285 } 9286 if value == nil { 9287 return nil 9288 } 9289 9290 shape, ok := value.(map[string]interface{}) 9291 if !ok { 9292 return fmt.Errorf("unexpected JSON type %v", value) 9293 } 9294 9295 var sv *types.BatchGetCustomDataIdentifierSummary 9296 if *v == nil { 9297 sv = &types.BatchGetCustomDataIdentifierSummary{} 9298 } else { 9299 sv = *v 9300 } 9301 9302 for key, value := range shape { 9303 switch key { 9304 case "arn": 9305 if value != nil { 9306 jtv, ok := value.(string) 9307 if !ok { 9308 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9309 } 9310 sv.Arn = ptr.String(jtv) 9311 } 9312 9313 case "createdAt": 9314 if value != nil { 9315 jtv, ok := value.(string) 9316 if !ok { 9317 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9318 } 9319 t, err := smithytime.ParseDateTime(jtv) 9320 if err != nil { 9321 return err 9322 } 9323 sv.CreatedAt = ptr.Time(t) 9324 } 9325 9326 case "deleted": 9327 if value != nil { 9328 jtv, ok := value.(bool) 9329 if !ok { 9330 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9331 } 9332 sv.Deleted = jtv 9333 } 9334 9335 case "description": 9336 if value != nil { 9337 jtv, ok := value.(string) 9338 if !ok { 9339 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9340 } 9341 sv.Description = ptr.String(jtv) 9342 } 9343 9344 case "id": 9345 if value != nil { 9346 jtv, ok := value.(string) 9347 if !ok { 9348 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9349 } 9350 sv.Id = ptr.String(jtv) 9351 } 9352 9353 case "name": 9354 if value != nil { 9355 jtv, ok := value.(string) 9356 if !ok { 9357 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9358 } 9359 sv.Name = ptr.String(jtv) 9360 } 9361 9362 default: 9363 _, _ = key, value 9364 9365 } 9366 } 9367 *v = sv 9368 return nil 9369} 9370 9371func awsRestjson1_deserializeDocumentBlockPublicAccess(v **types.BlockPublicAccess, value interface{}) error { 9372 if v == nil { 9373 return fmt.Errorf("unexpected nil of type %T", v) 9374 } 9375 if value == nil { 9376 return nil 9377 } 9378 9379 shape, ok := value.(map[string]interface{}) 9380 if !ok { 9381 return fmt.Errorf("unexpected JSON type %v", value) 9382 } 9383 9384 var sv *types.BlockPublicAccess 9385 if *v == nil { 9386 sv = &types.BlockPublicAccess{} 9387 } else { 9388 sv = *v 9389 } 9390 9391 for key, value := range shape { 9392 switch key { 9393 case "blockPublicAcls": 9394 if value != nil { 9395 jtv, ok := value.(bool) 9396 if !ok { 9397 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9398 } 9399 sv.BlockPublicAcls = jtv 9400 } 9401 9402 case "blockPublicPolicy": 9403 if value != nil { 9404 jtv, ok := value.(bool) 9405 if !ok { 9406 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9407 } 9408 sv.BlockPublicPolicy = jtv 9409 } 9410 9411 case "ignorePublicAcls": 9412 if value != nil { 9413 jtv, ok := value.(bool) 9414 if !ok { 9415 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9416 } 9417 sv.IgnorePublicAcls = jtv 9418 } 9419 9420 case "restrictPublicBuckets": 9421 if value != nil { 9422 jtv, ok := value.(bool) 9423 if !ok { 9424 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9425 } 9426 sv.RestrictPublicBuckets = jtv 9427 } 9428 9429 default: 9430 _, _ = key, value 9431 9432 } 9433 } 9434 *v = sv 9435 return nil 9436} 9437 9438func awsRestjson1_deserializeDocumentBucketCountByEffectivePermission(v **types.BucketCountByEffectivePermission, value interface{}) error { 9439 if v == nil { 9440 return fmt.Errorf("unexpected nil of type %T", v) 9441 } 9442 if value == nil { 9443 return nil 9444 } 9445 9446 shape, ok := value.(map[string]interface{}) 9447 if !ok { 9448 return fmt.Errorf("unexpected JSON type %v", value) 9449 } 9450 9451 var sv *types.BucketCountByEffectivePermission 9452 if *v == nil { 9453 sv = &types.BucketCountByEffectivePermission{} 9454 } else { 9455 sv = *v 9456 } 9457 9458 for key, value := range shape { 9459 switch key { 9460 case "publiclyAccessible": 9461 if value != nil { 9462 jtv, ok := value.(json.Number) 9463 if !ok { 9464 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9465 } 9466 i64, err := jtv.Int64() 9467 if err != nil { 9468 return err 9469 } 9470 sv.PubliclyAccessible = i64 9471 } 9472 9473 case "publiclyReadable": 9474 if value != nil { 9475 jtv, ok := value.(json.Number) 9476 if !ok { 9477 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9478 } 9479 i64, err := jtv.Int64() 9480 if err != nil { 9481 return err 9482 } 9483 sv.PubliclyReadable = i64 9484 } 9485 9486 case "publiclyWritable": 9487 if value != nil { 9488 jtv, ok := value.(json.Number) 9489 if !ok { 9490 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9491 } 9492 i64, err := jtv.Int64() 9493 if err != nil { 9494 return err 9495 } 9496 sv.PubliclyWritable = i64 9497 } 9498 9499 case "unknown": 9500 if value != nil { 9501 jtv, ok := value.(json.Number) 9502 if !ok { 9503 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9504 } 9505 i64, err := jtv.Int64() 9506 if err != nil { 9507 return err 9508 } 9509 sv.Unknown = i64 9510 } 9511 9512 default: 9513 _, _ = key, value 9514 9515 } 9516 } 9517 *v = sv 9518 return nil 9519} 9520 9521func awsRestjson1_deserializeDocumentBucketCountByEncryptionType(v **types.BucketCountByEncryptionType, value interface{}) error { 9522 if v == nil { 9523 return fmt.Errorf("unexpected nil of type %T", v) 9524 } 9525 if value == nil { 9526 return nil 9527 } 9528 9529 shape, ok := value.(map[string]interface{}) 9530 if !ok { 9531 return fmt.Errorf("unexpected JSON type %v", value) 9532 } 9533 9534 var sv *types.BucketCountByEncryptionType 9535 if *v == nil { 9536 sv = &types.BucketCountByEncryptionType{} 9537 } else { 9538 sv = *v 9539 } 9540 9541 for key, value := range shape { 9542 switch key { 9543 case "kmsManaged": 9544 if value != nil { 9545 jtv, ok := value.(json.Number) 9546 if !ok { 9547 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9548 } 9549 i64, err := jtv.Int64() 9550 if err != nil { 9551 return err 9552 } 9553 sv.KmsManaged = i64 9554 } 9555 9556 case "s3Managed": 9557 if value != nil { 9558 jtv, ok := value.(json.Number) 9559 if !ok { 9560 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9561 } 9562 i64, err := jtv.Int64() 9563 if err != nil { 9564 return err 9565 } 9566 sv.S3Managed = i64 9567 } 9568 9569 case "unencrypted": 9570 if value != nil { 9571 jtv, ok := value.(json.Number) 9572 if !ok { 9573 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9574 } 9575 i64, err := jtv.Int64() 9576 if err != nil { 9577 return err 9578 } 9579 sv.Unencrypted = i64 9580 } 9581 9582 default: 9583 _, _ = key, value 9584 9585 } 9586 } 9587 *v = sv 9588 return nil 9589} 9590 9591func awsRestjson1_deserializeDocumentBucketCountBySharedAccessType(v **types.BucketCountBySharedAccessType, value interface{}) error { 9592 if v == nil { 9593 return fmt.Errorf("unexpected nil of type %T", v) 9594 } 9595 if value == nil { 9596 return nil 9597 } 9598 9599 shape, ok := value.(map[string]interface{}) 9600 if !ok { 9601 return fmt.Errorf("unexpected JSON type %v", value) 9602 } 9603 9604 var sv *types.BucketCountBySharedAccessType 9605 if *v == nil { 9606 sv = &types.BucketCountBySharedAccessType{} 9607 } else { 9608 sv = *v 9609 } 9610 9611 for key, value := range shape { 9612 switch key { 9613 case "external": 9614 if value != nil { 9615 jtv, ok := value.(json.Number) 9616 if !ok { 9617 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9618 } 9619 i64, err := jtv.Int64() 9620 if err != nil { 9621 return err 9622 } 9623 sv.External = i64 9624 } 9625 9626 case "internal": 9627 if value != nil { 9628 jtv, ok := value.(json.Number) 9629 if !ok { 9630 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9631 } 9632 i64, err := jtv.Int64() 9633 if err != nil { 9634 return err 9635 } 9636 sv.Internal = i64 9637 } 9638 9639 case "notShared": 9640 if value != nil { 9641 jtv, ok := value.(json.Number) 9642 if !ok { 9643 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9644 } 9645 i64, err := jtv.Int64() 9646 if err != nil { 9647 return err 9648 } 9649 sv.NotShared = i64 9650 } 9651 9652 case "unknown": 9653 if value != nil { 9654 jtv, ok := value.(json.Number) 9655 if !ok { 9656 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9657 } 9658 i64, err := jtv.Int64() 9659 if err != nil { 9660 return err 9661 } 9662 sv.Unknown = i64 9663 } 9664 9665 default: 9666 _, _ = key, value 9667 9668 } 9669 } 9670 *v = sv 9671 return nil 9672} 9673 9674func awsRestjson1_deserializeDocumentBucketLevelPermissions(v **types.BucketLevelPermissions, value interface{}) error { 9675 if v == nil { 9676 return fmt.Errorf("unexpected nil of type %T", v) 9677 } 9678 if value == nil { 9679 return nil 9680 } 9681 9682 shape, ok := value.(map[string]interface{}) 9683 if !ok { 9684 return fmt.Errorf("unexpected JSON type %v", value) 9685 } 9686 9687 var sv *types.BucketLevelPermissions 9688 if *v == nil { 9689 sv = &types.BucketLevelPermissions{} 9690 } else { 9691 sv = *v 9692 } 9693 9694 for key, value := range shape { 9695 switch key { 9696 case "accessControlList": 9697 if err := awsRestjson1_deserializeDocumentAccessControlList(&sv.AccessControlList, value); err != nil { 9698 return err 9699 } 9700 9701 case "blockPublicAccess": 9702 if err := awsRestjson1_deserializeDocumentBlockPublicAccess(&sv.BlockPublicAccess, value); err != nil { 9703 return err 9704 } 9705 9706 case "bucketPolicy": 9707 if err := awsRestjson1_deserializeDocumentBucketPolicy(&sv.BucketPolicy, value); err != nil { 9708 return err 9709 } 9710 9711 default: 9712 _, _ = key, value 9713 9714 } 9715 } 9716 *v = sv 9717 return nil 9718} 9719 9720func awsRestjson1_deserializeDocumentBucketMetadata(v **types.BucketMetadata, value interface{}) error { 9721 if v == nil { 9722 return fmt.Errorf("unexpected nil of type %T", v) 9723 } 9724 if value == nil { 9725 return nil 9726 } 9727 9728 shape, ok := value.(map[string]interface{}) 9729 if !ok { 9730 return fmt.Errorf("unexpected JSON type %v", value) 9731 } 9732 9733 var sv *types.BucketMetadata 9734 if *v == nil { 9735 sv = &types.BucketMetadata{} 9736 } else { 9737 sv = *v 9738 } 9739 9740 for key, value := range shape { 9741 switch key { 9742 case "accountId": 9743 if value != nil { 9744 jtv, ok := value.(string) 9745 if !ok { 9746 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9747 } 9748 sv.AccountId = ptr.String(jtv) 9749 } 9750 9751 case "bucketArn": 9752 if value != nil { 9753 jtv, ok := value.(string) 9754 if !ok { 9755 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9756 } 9757 sv.BucketArn = ptr.String(jtv) 9758 } 9759 9760 case "bucketCreatedAt": 9761 if value != nil { 9762 jtv, ok := value.(string) 9763 if !ok { 9764 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9765 } 9766 t, err := smithytime.ParseDateTime(jtv) 9767 if err != nil { 9768 return err 9769 } 9770 sv.BucketCreatedAt = ptr.Time(t) 9771 } 9772 9773 case "bucketName": 9774 if value != nil { 9775 jtv, ok := value.(string) 9776 if !ok { 9777 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9778 } 9779 sv.BucketName = ptr.String(jtv) 9780 } 9781 9782 case "classifiableObjectCount": 9783 if value != nil { 9784 jtv, ok := value.(json.Number) 9785 if !ok { 9786 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9787 } 9788 i64, err := jtv.Int64() 9789 if err != nil { 9790 return err 9791 } 9792 sv.ClassifiableObjectCount = i64 9793 } 9794 9795 case "classifiableSizeInBytes": 9796 if value != nil { 9797 jtv, ok := value.(json.Number) 9798 if !ok { 9799 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9800 } 9801 i64, err := jtv.Int64() 9802 if err != nil { 9803 return err 9804 } 9805 sv.ClassifiableSizeInBytes = i64 9806 } 9807 9808 case "jobDetails": 9809 if err := awsRestjson1_deserializeDocumentJobDetails(&sv.JobDetails, value); err != nil { 9810 return err 9811 } 9812 9813 case "lastUpdated": 9814 if value != nil { 9815 jtv, ok := value.(string) 9816 if !ok { 9817 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9818 } 9819 t, err := smithytime.ParseDateTime(jtv) 9820 if err != nil { 9821 return err 9822 } 9823 sv.LastUpdated = ptr.Time(t) 9824 } 9825 9826 case "objectCount": 9827 if value != nil { 9828 jtv, ok := value.(json.Number) 9829 if !ok { 9830 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9831 } 9832 i64, err := jtv.Int64() 9833 if err != nil { 9834 return err 9835 } 9836 sv.ObjectCount = i64 9837 } 9838 9839 case "objectCountByEncryptionType": 9840 if err := awsRestjson1_deserializeDocumentObjectCountByEncryptionType(&sv.ObjectCountByEncryptionType, value); err != nil { 9841 return err 9842 } 9843 9844 case "publicAccess": 9845 if err := awsRestjson1_deserializeDocumentBucketPublicAccess(&sv.PublicAccess, value); err != nil { 9846 return err 9847 } 9848 9849 case "region": 9850 if value != nil { 9851 jtv, ok := value.(string) 9852 if !ok { 9853 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9854 } 9855 sv.Region = ptr.String(jtv) 9856 } 9857 9858 case "replicationDetails": 9859 if err := awsRestjson1_deserializeDocumentReplicationDetails(&sv.ReplicationDetails, value); err != nil { 9860 return err 9861 } 9862 9863 case "sharedAccess": 9864 if value != nil { 9865 jtv, ok := value.(string) 9866 if !ok { 9867 return fmt.Errorf("expected SharedAccess to be of type string, got %T instead", value) 9868 } 9869 sv.SharedAccess = types.SharedAccess(jtv) 9870 } 9871 9872 case "sizeInBytes": 9873 if value != nil { 9874 jtv, ok := value.(json.Number) 9875 if !ok { 9876 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9877 } 9878 i64, err := jtv.Int64() 9879 if err != nil { 9880 return err 9881 } 9882 sv.SizeInBytes = i64 9883 } 9884 9885 case "sizeInBytesCompressed": 9886 if value != nil { 9887 jtv, ok := value.(json.Number) 9888 if !ok { 9889 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 9890 } 9891 i64, err := jtv.Int64() 9892 if err != nil { 9893 return err 9894 } 9895 sv.SizeInBytesCompressed = i64 9896 } 9897 9898 case "tags": 9899 if err := awsRestjson1_deserializeDocument__listOfKeyValuePair(&sv.Tags, value); err != nil { 9900 return err 9901 } 9902 9903 case "unclassifiableObjectCount": 9904 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectCount, value); err != nil { 9905 return err 9906 } 9907 9908 case "unclassifiableObjectSizeInBytes": 9909 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectSizeInBytes, value); err != nil { 9910 return err 9911 } 9912 9913 case "versioning": 9914 if value != nil { 9915 jtv, ok := value.(bool) 9916 if !ok { 9917 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9918 } 9919 sv.Versioning = jtv 9920 } 9921 9922 default: 9923 _, _ = key, value 9924 9925 } 9926 } 9927 *v = sv 9928 return nil 9929} 9930 9931func awsRestjson1_deserializeDocumentBucketPermissionConfiguration(v **types.BucketPermissionConfiguration, value interface{}) error { 9932 if v == nil { 9933 return fmt.Errorf("unexpected nil of type %T", v) 9934 } 9935 if value == nil { 9936 return nil 9937 } 9938 9939 shape, ok := value.(map[string]interface{}) 9940 if !ok { 9941 return fmt.Errorf("unexpected JSON type %v", value) 9942 } 9943 9944 var sv *types.BucketPermissionConfiguration 9945 if *v == nil { 9946 sv = &types.BucketPermissionConfiguration{} 9947 } else { 9948 sv = *v 9949 } 9950 9951 for key, value := range shape { 9952 switch key { 9953 case "accountLevelPermissions": 9954 if err := awsRestjson1_deserializeDocumentAccountLevelPermissions(&sv.AccountLevelPermissions, value); err != nil { 9955 return err 9956 } 9957 9958 case "bucketLevelPermissions": 9959 if err := awsRestjson1_deserializeDocumentBucketLevelPermissions(&sv.BucketLevelPermissions, value); err != nil { 9960 return err 9961 } 9962 9963 default: 9964 _, _ = key, value 9965 9966 } 9967 } 9968 *v = sv 9969 return nil 9970} 9971 9972func awsRestjson1_deserializeDocumentBucketPolicy(v **types.BucketPolicy, value interface{}) error { 9973 if v == nil { 9974 return fmt.Errorf("unexpected nil of type %T", v) 9975 } 9976 if value == nil { 9977 return nil 9978 } 9979 9980 shape, ok := value.(map[string]interface{}) 9981 if !ok { 9982 return fmt.Errorf("unexpected JSON type %v", value) 9983 } 9984 9985 var sv *types.BucketPolicy 9986 if *v == nil { 9987 sv = &types.BucketPolicy{} 9988 } else { 9989 sv = *v 9990 } 9991 9992 for key, value := range shape { 9993 switch key { 9994 case "allowsPublicReadAccess": 9995 if value != nil { 9996 jtv, ok := value.(bool) 9997 if !ok { 9998 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9999 } 10000 sv.AllowsPublicReadAccess = jtv 10001 } 10002 10003 case "allowsPublicWriteAccess": 10004 if value != nil { 10005 jtv, ok := value.(bool) 10006 if !ok { 10007 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 10008 } 10009 sv.AllowsPublicWriteAccess = jtv 10010 } 10011 10012 default: 10013 _, _ = key, value 10014 10015 } 10016 } 10017 *v = sv 10018 return nil 10019} 10020 10021func awsRestjson1_deserializeDocumentBucketPublicAccess(v **types.BucketPublicAccess, value interface{}) error { 10022 if v == nil { 10023 return fmt.Errorf("unexpected nil of type %T", v) 10024 } 10025 if value == nil { 10026 return nil 10027 } 10028 10029 shape, ok := value.(map[string]interface{}) 10030 if !ok { 10031 return fmt.Errorf("unexpected JSON type %v", value) 10032 } 10033 10034 var sv *types.BucketPublicAccess 10035 if *v == nil { 10036 sv = &types.BucketPublicAccess{} 10037 } else { 10038 sv = *v 10039 } 10040 10041 for key, value := range shape { 10042 switch key { 10043 case "effectivePermission": 10044 if value != nil { 10045 jtv, ok := value.(string) 10046 if !ok { 10047 return fmt.Errorf("expected EffectivePermission to be of type string, got %T instead", value) 10048 } 10049 sv.EffectivePermission = types.EffectivePermission(jtv) 10050 } 10051 10052 case "permissionConfiguration": 10053 if err := awsRestjson1_deserializeDocumentBucketPermissionConfiguration(&sv.PermissionConfiguration, value); err != nil { 10054 return err 10055 } 10056 10057 default: 10058 _, _ = key, value 10059 10060 } 10061 } 10062 *v = sv 10063 return nil 10064} 10065 10066func awsRestjson1_deserializeDocumentCell(v **types.Cell, value interface{}) error { 10067 if v == nil { 10068 return fmt.Errorf("unexpected nil of type %T", v) 10069 } 10070 if value == nil { 10071 return nil 10072 } 10073 10074 shape, ok := value.(map[string]interface{}) 10075 if !ok { 10076 return fmt.Errorf("unexpected JSON type %v", value) 10077 } 10078 10079 var sv *types.Cell 10080 if *v == nil { 10081 sv = &types.Cell{} 10082 } else { 10083 sv = *v 10084 } 10085 10086 for key, value := range shape { 10087 switch key { 10088 case "cellReference": 10089 if value != nil { 10090 jtv, ok := value.(string) 10091 if !ok { 10092 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10093 } 10094 sv.CellReference = ptr.String(jtv) 10095 } 10096 10097 case "column": 10098 if value != nil { 10099 jtv, ok := value.(json.Number) 10100 if !ok { 10101 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10102 } 10103 i64, err := jtv.Int64() 10104 if err != nil { 10105 return err 10106 } 10107 sv.Column = i64 10108 } 10109 10110 case "columnName": 10111 if value != nil { 10112 jtv, ok := value.(string) 10113 if !ok { 10114 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10115 } 10116 sv.ColumnName = ptr.String(jtv) 10117 } 10118 10119 case "row": 10120 if value != nil { 10121 jtv, ok := value.(json.Number) 10122 if !ok { 10123 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10124 } 10125 i64, err := jtv.Int64() 10126 if err != nil { 10127 return err 10128 } 10129 sv.Row = i64 10130 } 10131 10132 default: 10133 _, _ = key, value 10134 10135 } 10136 } 10137 *v = sv 10138 return nil 10139} 10140 10141func awsRestjson1_deserializeDocumentCells(v *[]types.Cell, value interface{}) error { 10142 if v == nil { 10143 return fmt.Errorf("unexpected nil of type %T", v) 10144 } 10145 if value == nil { 10146 return nil 10147 } 10148 10149 shape, ok := value.([]interface{}) 10150 if !ok { 10151 return fmt.Errorf("unexpected JSON type %v", value) 10152 } 10153 10154 var cv []types.Cell 10155 if *v == nil { 10156 cv = []types.Cell{} 10157 } else { 10158 cv = *v 10159 } 10160 10161 for _, value := range shape { 10162 var col types.Cell 10163 destAddr := &col 10164 if err := awsRestjson1_deserializeDocumentCell(&destAddr, value); err != nil { 10165 return err 10166 } 10167 col = *destAddr 10168 cv = append(cv, col) 10169 10170 } 10171 *v = cv 10172 return nil 10173} 10174 10175func awsRestjson1_deserializeDocumentClassificationDetails(v **types.ClassificationDetails, value interface{}) error { 10176 if v == nil { 10177 return fmt.Errorf("unexpected nil of type %T", v) 10178 } 10179 if value == nil { 10180 return nil 10181 } 10182 10183 shape, ok := value.(map[string]interface{}) 10184 if !ok { 10185 return fmt.Errorf("unexpected JSON type %v", value) 10186 } 10187 10188 var sv *types.ClassificationDetails 10189 if *v == nil { 10190 sv = &types.ClassificationDetails{} 10191 } else { 10192 sv = *v 10193 } 10194 10195 for key, value := range shape { 10196 switch key { 10197 case "detailedResultsLocation": 10198 if value != nil { 10199 jtv, ok := value.(string) 10200 if !ok { 10201 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10202 } 10203 sv.DetailedResultsLocation = ptr.String(jtv) 10204 } 10205 10206 case "jobArn": 10207 if value != nil { 10208 jtv, ok := value.(string) 10209 if !ok { 10210 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10211 } 10212 sv.JobArn = ptr.String(jtv) 10213 } 10214 10215 case "jobId": 10216 if value != nil { 10217 jtv, ok := value.(string) 10218 if !ok { 10219 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10220 } 10221 sv.JobId = ptr.String(jtv) 10222 } 10223 10224 case "result": 10225 if err := awsRestjson1_deserializeDocumentClassificationResult(&sv.Result, value); err != nil { 10226 return err 10227 } 10228 10229 default: 10230 _, _ = key, value 10231 10232 } 10233 } 10234 *v = sv 10235 return nil 10236} 10237 10238func awsRestjson1_deserializeDocumentClassificationExportConfiguration(v **types.ClassificationExportConfiguration, value interface{}) error { 10239 if v == nil { 10240 return fmt.Errorf("unexpected nil of type %T", v) 10241 } 10242 if value == nil { 10243 return nil 10244 } 10245 10246 shape, ok := value.(map[string]interface{}) 10247 if !ok { 10248 return fmt.Errorf("unexpected JSON type %v", value) 10249 } 10250 10251 var sv *types.ClassificationExportConfiguration 10252 if *v == nil { 10253 sv = &types.ClassificationExportConfiguration{} 10254 } else { 10255 sv = *v 10256 } 10257 10258 for key, value := range shape { 10259 switch key { 10260 case "s3Destination": 10261 if err := awsRestjson1_deserializeDocumentS3Destination(&sv.S3Destination, value); err != nil { 10262 return err 10263 } 10264 10265 default: 10266 _, _ = key, value 10267 10268 } 10269 } 10270 *v = sv 10271 return nil 10272} 10273 10274func awsRestjson1_deserializeDocumentClassificationResult(v **types.ClassificationResult, value interface{}) error { 10275 if v == nil { 10276 return fmt.Errorf("unexpected nil of type %T", v) 10277 } 10278 if value == nil { 10279 return nil 10280 } 10281 10282 shape, ok := value.(map[string]interface{}) 10283 if !ok { 10284 return fmt.Errorf("unexpected JSON type %v", value) 10285 } 10286 10287 var sv *types.ClassificationResult 10288 if *v == nil { 10289 sv = &types.ClassificationResult{} 10290 } else { 10291 sv = *v 10292 } 10293 10294 for key, value := range shape { 10295 switch key { 10296 case "additionalOccurrences": 10297 if value != nil { 10298 jtv, ok := value.(bool) 10299 if !ok { 10300 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 10301 } 10302 sv.AdditionalOccurrences = jtv 10303 } 10304 10305 case "customDataIdentifiers": 10306 if err := awsRestjson1_deserializeDocumentCustomDataIdentifiers(&sv.CustomDataIdentifiers, value); err != nil { 10307 return err 10308 } 10309 10310 case "mimeType": 10311 if value != nil { 10312 jtv, ok := value.(string) 10313 if !ok { 10314 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10315 } 10316 sv.MimeType = ptr.String(jtv) 10317 } 10318 10319 case "sensitiveData": 10320 if err := awsRestjson1_deserializeDocumentSensitiveData(&sv.SensitiveData, value); err != nil { 10321 return err 10322 } 10323 10324 case "sizeClassified": 10325 if value != nil { 10326 jtv, ok := value.(json.Number) 10327 if !ok { 10328 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10329 } 10330 i64, err := jtv.Int64() 10331 if err != nil { 10332 return err 10333 } 10334 sv.SizeClassified = i64 10335 } 10336 10337 case "status": 10338 if err := awsRestjson1_deserializeDocumentClassificationResultStatus(&sv.Status, value); err != nil { 10339 return err 10340 } 10341 10342 default: 10343 _, _ = key, value 10344 10345 } 10346 } 10347 *v = sv 10348 return nil 10349} 10350 10351func awsRestjson1_deserializeDocumentClassificationResultStatus(v **types.ClassificationResultStatus, value interface{}) error { 10352 if v == nil { 10353 return fmt.Errorf("unexpected nil of type %T", v) 10354 } 10355 if value == nil { 10356 return nil 10357 } 10358 10359 shape, ok := value.(map[string]interface{}) 10360 if !ok { 10361 return fmt.Errorf("unexpected JSON type %v", value) 10362 } 10363 10364 var sv *types.ClassificationResultStatus 10365 if *v == nil { 10366 sv = &types.ClassificationResultStatus{} 10367 } else { 10368 sv = *v 10369 } 10370 10371 for key, value := range shape { 10372 switch key { 10373 case "code": 10374 if value != nil { 10375 jtv, ok := value.(string) 10376 if !ok { 10377 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10378 } 10379 sv.Code = ptr.String(jtv) 10380 } 10381 10382 case "reason": 10383 if value != nil { 10384 jtv, ok := value.(string) 10385 if !ok { 10386 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10387 } 10388 sv.Reason = ptr.String(jtv) 10389 } 10390 10391 default: 10392 _, _ = key, value 10393 10394 } 10395 } 10396 *v = sv 10397 return nil 10398} 10399 10400func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 10401 if v == nil { 10402 return fmt.Errorf("unexpected nil of type %T", v) 10403 } 10404 if value == nil { 10405 return nil 10406 } 10407 10408 shape, ok := value.(map[string]interface{}) 10409 if !ok { 10410 return fmt.Errorf("unexpected JSON type %v", value) 10411 } 10412 10413 var sv *types.ConflictException 10414 if *v == nil { 10415 sv = &types.ConflictException{} 10416 } else { 10417 sv = *v 10418 } 10419 10420 for key, value := range shape { 10421 switch key { 10422 case "message": 10423 if value != nil { 10424 jtv, ok := value.(string) 10425 if !ok { 10426 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10427 } 10428 sv.Message = ptr.String(jtv) 10429 } 10430 10431 default: 10432 _, _ = key, value 10433 10434 } 10435 } 10436 *v = sv 10437 return nil 10438} 10439 10440func awsRestjson1_deserializeDocumentCriterion(v *map[string]types.CriterionAdditionalProperties, value interface{}) error { 10441 if v == nil { 10442 return fmt.Errorf("unexpected nil of type %T", v) 10443 } 10444 if value == nil { 10445 return nil 10446 } 10447 10448 shape, ok := value.(map[string]interface{}) 10449 if !ok { 10450 return fmt.Errorf("unexpected JSON type %v", value) 10451 } 10452 10453 var mv map[string]types.CriterionAdditionalProperties 10454 if *v == nil { 10455 mv = map[string]types.CriterionAdditionalProperties{} 10456 } else { 10457 mv = *v 10458 } 10459 10460 for key, value := range shape { 10461 var parsedVal types.CriterionAdditionalProperties 10462 mapVar := parsedVal 10463 destAddr := &mapVar 10464 if err := awsRestjson1_deserializeDocumentCriterionAdditionalProperties(&destAddr, value); err != nil { 10465 return err 10466 } 10467 parsedVal = *destAddr 10468 mv[key] = parsedVal 10469 10470 } 10471 *v = mv 10472 return nil 10473} 10474 10475func awsRestjson1_deserializeDocumentCriterionAdditionalProperties(v **types.CriterionAdditionalProperties, value interface{}) error { 10476 if v == nil { 10477 return fmt.Errorf("unexpected nil of type %T", v) 10478 } 10479 if value == nil { 10480 return nil 10481 } 10482 10483 shape, ok := value.(map[string]interface{}) 10484 if !ok { 10485 return fmt.Errorf("unexpected JSON type %v", value) 10486 } 10487 10488 var sv *types.CriterionAdditionalProperties 10489 if *v == nil { 10490 sv = &types.CriterionAdditionalProperties{} 10491 } else { 10492 sv = *v 10493 } 10494 10495 for key, value := range shape { 10496 switch key { 10497 case "eq": 10498 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Eq, value); err != nil { 10499 return err 10500 } 10501 10502 case "eqExactMatch": 10503 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.EqExactMatch, value); err != nil { 10504 return err 10505 } 10506 10507 case "gt": 10508 if value != nil { 10509 jtv, ok := value.(json.Number) 10510 if !ok { 10511 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10512 } 10513 i64, err := jtv.Int64() 10514 if err != nil { 10515 return err 10516 } 10517 sv.Gt = i64 10518 } 10519 10520 case "gte": 10521 if value != nil { 10522 jtv, ok := value.(json.Number) 10523 if !ok { 10524 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10525 } 10526 i64, err := jtv.Int64() 10527 if err != nil { 10528 return err 10529 } 10530 sv.Gte = i64 10531 } 10532 10533 case "lt": 10534 if value != nil { 10535 jtv, ok := value.(json.Number) 10536 if !ok { 10537 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10538 } 10539 i64, err := jtv.Int64() 10540 if err != nil { 10541 return err 10542 } 10543 sv.Lt = i64 10544 } 10545 10546 case "lte": 10547 if value != nil { 10548 jtv, ok := value.(json.Number) 10549 if !ok { 10550 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10551 } 10552 i64, err := jtv.Int64() 10553 if err != nil { 10554 return err 10555 } 10556 sv.Lte = i64 10557 } 10558 10559 case "neq": 10560 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Neq, value); err != nil { 10561 return err 10562 } 10563 10564 default: 10565 _, _ = key, value 10566 10567 } 10568 } 10569 *v = sv 10570 return nil 10571} 10572 10573func awsRestjson1_deserializeDocumentCustomDataIdentifiers(v **types.CustomDataIdentifiers, value interface{}) error { 10574 if v == nil { 10575 return fmt.Errorf("unexpected nil of type %T", v) 10576 } 10577 if value == nil { 10578 return nil 10579 } 10580 10581 shape, ok := value.(map[string]interface{}) 10582 if !ok { 10583 return fmt.Errorf("unexpected JSON type %v", value) 10584 } 10585 10586 var sv *types.CustomDataIdentifiers 10587 if *v == nil { 10588 sv = &types.CustomDataIdentifiers{} 10589 } else { 10590 sv = *v 10591 } 10592 10593 for key, value := range shape { 10594 switch key { 10595 case "detections": 10596 if err := awsRestjson1_deserializeDocumentCustomDetections(&sv.Detections, value); err != nil { 10597 return err 10598 } 10599 10600 case "totalCount": 10601 if value != nil { 10602 jtv, ok := value.(json.Number) 10603 if !ok { 10604 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10605 } 10606 i64, err := jtv.Int64() 10607 if err != nil { 10608 return err 10609 } 10610 sv.TotalCount = i64 10611 } 10612 10613 default: 10614 _, _ = key, value 10615 10616 } 10617 } 10618 *v = sv 10619 return nil 10620} 10621 10622func awsRestjson1_deserializeDocumentCustomDataIdentifierSummary(v **types.CustomDataIdentifierSummary, value interface{}) error { 10623 if v == nil { 10624 return fmt.Errorf("unexpected nil of type %T", v) 10625 } 10626 if value == nil { 10627 return nil 10628 } 10629 10630 shape, ok := value.(map[string]interface{}) 10631 if !ok { 10632 return fmt.Errorf("unexpected JSON type %v", value) 10633 } 10634 10635 var sv *types.CustomDataIdentifierSummary 10636 if *v == nil { 10637 sv = &types.CustomDataIdentifierSummary{} 10638 } else { 10639 sv = *v 10640 } 10641 10642 for key, value := range shape { 10643 switch key { 10644 case "arn": 10645 if value != nil { 10646 jtv, ok := value.(string) 10647 if !ok { 10648 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10649 } 10650 sv.Arn = ptr.String(jtv) 10651 } 10652 10653 case "createdAt": 10654 if value != nil { 10655 jtv, ok := value.(string) 10656 if !ok { 10657 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 10658 } 10659 t, err := smithytime.ParseDateTime(jtv) 10660 if err != nil { 10661 return err 10662 } 10663 sv.CreatedAt = ptr.Time(t) 10664 } 10665 10666 case "description": 10667 if value != nil { 10668 jtv, ok := value.(string) 10669 if !ok { 10670 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10671 } 10672 sv.Description = ptr.String(jtv) 10673 } 10674 10675 case "id": 10676 if value != nil { 10677 jtv, ok := value.(string) 10678 if !ok { 10679 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10680 } 10681 sv.Id = ptr.String(jtv) 10682 } 10683 10684 case "name": 10685 if value != nil { 10686 jtv, ok := value.(string) 10687 if !ok { 10688 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10689 } 10690 sv.Name = ptr.String(jtv) 10691 } 10692 10693 default: 10694 _, _ = key, value 10695 10696 } 10697 } 10698 *v = sv 10699 return nil 10700} 10701 10702func awsRestjson1_deserializeDocumentCustomDetection(v **types.CustomDetection, value interface{}) error { 10703 if v == nil { 10704 return fmt.Errorf("unexpected nil of type %T", v) 10705 } 10706 if value == nil { 10707 return nil 10708 } 10709 10710 shape, ok := value.(map[string]interface{}) 10711 if !ok { 10712 return fmt.Errorf("unexpected JSON type %v", value) 10713 } 10714 10715 var sv *types.CustomDetection 10716 if *v == nil { 10717 sv = &types.CustomDetection{} 10718 } else { 10719 sv = *v 10720 } 10721 10722 for key, value := range shape { 10723 switch key { 10724 case "arn": 10725 if value != nil { 10726 jtv, ok := value.(string) 10727 if !ok { 10728 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10729 } 10730 sv.Arn = ptr.String(jtv) 10731 } 10732 10733 case "count": 10734 if value != nil { 10735 jtv, ok := value.(json.Number) 10736 if !ok { 10737 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10738 } 10739 i64, err := jtv.Int64() 10740 if err != nil { 10741 return err 10742 } 10743 sv.Count = i64 10744 } 10745 10746 case "name": 10747 if value != nil { 10748 jtv, ok := value.(string) 10749 if !ok { 10750 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10751 } 10752 sv.Name = ptr.String(jtv) 10753 } 10754 10755 case "occurrences": 10756 if err := awsRestjson1_deserializeDocumentOccurrences(&sv.Occurrences, value); err != nil { 10757 return err 10758 } 10759 10760 default: 10761 _, _ = key, value 10762 10763 } 10764 } 10765 *v = sv 10766 return nil 10767} 10768 10769func awsRestjson1_deserializeDocumentCustomDetections(v *[]types.CustomDetection, value interface{}) error { 10770 if v == nil { 10771 return fmt.Errorf("unexpected nil of type %T", v) 10772 } 10773 if value == nil { 10774 return nil 10775 } 10776 10777 shape, ok := value.([]interface{}) 10778 if !ok { 10779 return fmt.Errorf("unexpected JSON type %v", value) 10780 } 10781 10782 var cv []types.CustomDetection 10783 if *v == nil { 10784 cv = []types.CustomDetection{} 10785 } else { 10786 cv = *v 10787 } 10788 10789 for _, value := range shape { 10790 var col types.CustomDetection 10791 destAddr := &col 10792 if err := awsRestjson1_deserializeDocumentCustomDetection(&destAddr, value); err != nil { 10793 return err 10794 } 10795 col = *destAddr 10796 cv = append(cv, col) 10797 10798 } 10799 *v = cv 10800 return nil 10801} 10802 10803func awsRestjson1_deserializeDocumentDailySchedule(v **types.DailySchedule, value interface{}) error { 10804 if v == nil { 10805 return fmt.Errorf("unexpected nil of type %T", v) 10806 } 10807 if value == nil { 10808 return nil 10809 } 10810 10811 shape, ok := value.(map[string]interface{}) 10812 if !ok { 10813 return fmt.Errorf("unexpected JSON type %v", value) 10814 } 10815 10816 var sv *types.DailySchedule 10817 if *v == nil { 10818 sv = &types.DailySchedule{} 10819 } else { 10820 sv = *v 10821 } 10822 10823 for key, value := range shape { 10824 switch key { 10825 default: 10826 _, _ = key, value 10827 10828 } 10829 } 10830 *v = sv 10831 return nil 10832} 10833 10834func awsRestjson1_deserializeDocumentDefaultDetection(v **types.DefaultDetection, value interface{}) error { 10835 if v == nil { 10836 return fmt.Errorf("unexpected nil of type %T", v) 10837 } 10838 if value == nil { 10839 return nil 10840 } 10841 10842 shape, ok := value.(map[string]interface{}) 10843 if !ok { 10844 return fmt.Errorf("unexpected JSON type %v", value) 10845 } 10846 10847 var sv *types.DefaultDetection 10848 if *v == nil { 10849 sv = &types.DefaultDetection{} 10850 } else { 10851 sv = *v 10852 } 10853 10854 for key, value := range shape { 10855 switch key { 10856 case "count": 10857 if value != nil { 10858 jtv, ok := value.(json.Number) 10859 if !ok { 10860 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10861 } 10862 i64, err := jtv.Int64() 10863 if err != nil { 10864 return err 10865 } 10866 sv.Count = i64 10867 } 10868 10869 case "occurrences": 10870 if err := awsRestjson1_deserializeDocumentOccurrences(&sv.Occurrences, value); err != nil { 10871 return err 10872 } 10873 10874 case "type": 10875 if value != nil { 10876 jtv, ok := value.(string) 10877 if !ok { 10878 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10879 } 10880 sv.Type = ptr.String(jtv) 10881 } 10882 10883 default: 10884 _, _ = key, value 10885 10886 } 10887 } 10888 *v = sv 10889 return nil 10890} 10891 10892func awsRestjson1_deserializeDocumentDefaultDetections(v *[]types.DefaultDetection, value interface{}) error { 10893 if v == nil { 10894 return fmt.Errorf("unexpected nil of type %T", v) 10895 } 10896 if value == nil { 10897 return nil 10898 } 10899 10900 shape, ok := value.([]interface{}) 10901 if !ok { 10902 return fmt.Errorf("unexpected JSON type %v", value) 10903 } 10904 10905 var cv []types.DefaultDetection 10906 if *v == nil { 10907 cv = []types.DefaultDetection{} 10908 } else { 10909 cv = *v 10910 } 10911 10912 for _, value := range shape { 10913 var col types.DefaultDetection 10914 destAddr := &col 10915 if err := awsRestjson1_deserializeDocumentDefaultDetection(&destAddr, value); err != nil { 10916 return err 10917 } 10918 col = *destAddr 10919 cv = append(cv, col) 10920 10921 } 10922 *v = cv 10923 return nil 10924} 10925 10926func awsRestjson1_deserializeDocumentDomainDetails(v **types.DomainDetails, value interface{}) error { 10927 if v == nil { 10928 return fmt.Errorf("unexpected nil of type %T", v) 10929 } 10930 if value == nil { 10931 return nil 10932 } 10933 10934 shape, ok := value.(map[string]interface{}) 10935 if !ok { 10936 return fmt.Errorf("unexpected JSON type %v", value) 10937 } 10938 10939 var sv *types.DomainDetails 10940 if *v == nil { 10941 sv = &types.DomainDetails{} 10942 } else { 10943 sv = *v 10944 } 10945 10946 for key, value := range shape { 10947 switch key { 10948 case "domainName": 10949 if value != nil { 10950 jtv, ok := value.(string) 10951 if !ok { 10952 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10953 } 10954 sv.DomainName = ptr.String(jtv) 10955 } 10956 10957 default: 10958 _, _ = key, value 10959 10960 } 10961 } 10962 *v = sv 10963 return nil 10964} 10965 10966func awsRestjson1_deserializeDocumentFederatedUser(v **types.FederatedUser, value interface{}) error { 10967 if v == nil { 10968 return fmt.Errorf("unexpected nil of type %T", v) 10969 } 10970 if value == nil { 10971 return nil 10972 } 10973 10974 shape, ok := value.(map[string]interface{}) 10975 if !ok { 10976 return fmt.Errorf("unexpected JSON type %v", value) 10977 } 10978 10979 var sv *types.FederatedUser 10980 if *v == nil { 10981 sv = &types.FederatedUser{} 10982 } else { 10983 sv = *v 10984 } 10985 10986 for key, value := range shape { 10987 switch key { 10988 case "accessKeyId": 10989 if value != nil { 10990 jtv, ok := value.(string) 10991 if !ok { 10992 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10993 } 10994 sv.AccessKeyId = ptr.String(jtv) 10995 } 10996 10997 case "accountId": 10998 if value != nil { 10999 jtv, ok := value.(string) 11000 if !ok { 11001 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11002 } 11003 sv.AccountId = ptr.String(jtv) 11004 } 11005 11006 case "arn": 11007 if value != nil { 11008 jtv, ok := value.(string) 11009 if !ok { 11010 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11011 } 11012 sv.Arn = ptr.String(jtv) 11013 } 11014 11015 case "principalId": 11016 if value != nil { 11017 jtv, ok := value.(string) 11018 if !ok { 11019 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11020 } 11021 sv.PrincipalId = ptr.String(jtv) 11022 } 11023 11024 case "sessionContext": 11025 if err := awsRestjson1_deserializeDocumentSessionContext(&sv.SessionContext, value); err != nil { 11026 return err 11027 } 11028 11029 default: 11030 _, _ = key, value 11031 11032 } 11033 } 11034 *v = sv 11035 return nil 11036} 11037 11038func awsRestjson1_deserializeDocumentFinding(v **types.Finding, value interface{}) error { 11039 if v == nil { 11040 return fmt.Errorf("unexpected nil of type %T", v) 11041 } 11042 if value == nil { 11043 return nil 11044 } 11045 11046 shape, ok := value.(map[string]interface{}) 11047 if !ok { 11048 return fmt.Errorf("unexpected JSON type %v", value) 11049 } 11050 11051 var sv *types.Finding 11052 if *v == nil { 11053 sv = &types.Finding{} 11054 } else { 11055 sv = *v 11056 } 11057 11058 for key, value := range shape { 11059 switch key { 11060 case "accountId": 11061 if value != nil { 11062 jtv, ok := value.(string) 11063 if !ok { 11064 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11065 } 11066 sv.AccountId = ptr.String(jtv) 11067 } 11068 11069 case "archived": 11070 if value != nil { 11071 jtv, ok := value.(bool) 11072 if !ok { 11073 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 11074 } 11075 sv.Archived = jtv 11076 } 11077 11078 case "category": 11079 if value != nil { 11080 jtv, ok := value.(string) 11081 if !ok { 11082 return fmt.Errorf("expected FindingCategory to be of type string, got %T instead", value) 11083 } 11084 sv.Category = types.FindingCategory(jtv) 11085 } 11086 11087 case "classificationDetails": 11088 if err := awsRestjson1_deserializeDocumentClassificationDetails(&sv.ClassificationDetails, value); err != nil { 11089 return err 11090 } 11091 11092 case "count": 11093 if value != nil { 11094 jtv, ok := value.(json.Number) 11095 if !ok { 11096 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11097 } 11098 i64, err := jtv.Int64() 11099 if err != nil { 11100 return err 11101 } 11102 sv.Count = i64 11103 } 11104 11105 case "createdAt": 11106 if value != nil { 11107 jtv, ok := value.(string) 11108 if !ok { 11109 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 11110 } 11111 t, err := smithytime.ParseDateTime(jtv) 11112 if err != nil { 11113 return err 11114 } 11115 sv.CreatedAt = ptr.Time(t) 11116 } 11117 11118 case "description": 11119 if value != nil { 11120 jtv, ok := value.(string) 11121 if !ok { 11122 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11123 } 11124 sv.Description = ptr.String(jtv) 11125 } 11126 11127 case "id": 11128 if value != nil { 11129 jtv, ok := value.(string) 11130 if !ok { 11131 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11132 } 11133 sv.Id = ptr.String(jtv) 11134 } 11135 11136 case "partition": 11137 if value != nil { 11138 jtv, ok := value.(string) 11139 if !ok { 11140 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11141 } 11142 sv.Partition = ptr.String(jtv) 11143 } 11144 11145 case "policyDetails": 11146 if err := awsRestjson1_deserializeDocumentPolicyDetails(&sv.PolicyDetails, value); err != nil { 11147 return err 11148 } 11149 11150 case "region": 11151 if value != nil { 11152 jtv, ok := value.(string) 11153 if !ok { 11154 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11155 } 11156 sv.Region = ptr.String(jtv) 11157 } 11158 11159 case "resourcesAffected": 11160 if err := awsRestjson1_deserializeDocumentResourcesAffected(&sv.ResourcesAffected, value); err != nil { 11161 return err 11162 } 11163 11164 case "sample": 11165 if value != nil { 11166 jtv, ok := value.(bool) 11167 if !ok { 11168 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 11169 } 11170 sv.Sample = jtv 11171 } 11172 11173 case "schemaVersion": 11174 if value != nil { 11175 jtv, ok := value.(string) 11176 if !ok { 11177 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11178 } 11179 sv.SchemaVersion = ptr.String(jtv) 11180 } 11181 11182 case "severity": 11183 if err := awsRestjson1_deserializeDocumentSeverity(&sv.Severity, value); err != nil { 11184 return err 11185 } 11186 11187 case "title": 11188 if value != nil { 11189 jtv, ok := value.(string) 11190 if !ok { 11191 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11192 } 11193 sv.Title = ptr.String(jtv) 11194 } 11195 11196 case "type": 11197 if value != nil { 11198 jtv, ok := value.(string) 11199 if !ok { 11200 return fmt.Errorf("expected FindingType to be of type string, got %T instead", value) 11201 } 11202 sv.Type = types.FindingType(jtv) 11203 } 11204 11205 case "updatedAt": 11206 if value != nil { 11207 jtv, ok := value.(string) 11208 if !ok { 11209 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 11210 } 11211 t, err := smithytime.ParseDateTime(jtv) 11212 if err != nil { 11213 return err 11214 } 11215 sv.UpdatedAt = ptr.Time(t) 11216 } 11217 11218 default: 11219 _, _ = key, value 11220 11221 } 11222 } 11223 *v = sv 11224 return nil 11225} 11226 11227func awsRestjson1_deserializeDocumentFindingAction(v **types.FindingAction, value interface{}) error { 11228 if v == nil { 11229 return fmt.Errorf("unexpected nil of type %T", v) 11230 } 11231 if value == nil { 11232 return nil 11233 } 11234 11235 shape, ok := value.(map[string]interface{}) 11236 if !ok { 11237 return fmt.Errorf("unexpected JSON type %v", value) 11238 } 11239 11240 var sv *types.FindingAction 11241 if *v == nil { 11242 sv = &types.FindingAction{} 11243 } else { 11244 sv = *v 11245 } 11246 11247 for key, value := range shape { 11248 switch key { 11249 case "actionType": 11250 if value != nil { 11251 jtv, ok := value.(string) 11252 if !ok { 11253 return fmt.Errorf("expected FindingActionType to be of type string, got %T instead", value) 11254 } 11255 sv.ActionType = types.FindingActionType(jtv) 11256 } 11257 11258 case "apiCallDetails": 11259 if err := awsRestjson1_deserializeDocumentApiCallDetails(&sv.ApiCallDetails, value); err != nil { 11260 return err 11261 } 11262 11263 default: 11264 _, _ = key, value 11265 11266 } 11267 } 11268 *v = sv 11269 return nil 11270} 11271 11272func awsRestjson1_deserializeDocumentFindingActor(v **types.FindingActor, value interface{}) error { 11273 if v == nil { 11274 return fmt.Errorf("unexpected nil of type %T", v) 11275 } 11276 if value == nil { 11277 return nil 11278 } 11279 11280 shape, ok := value.(map[string]interface{}) 11281 if !ok { 11282 return fmt.Errorf("unexpected JSON type %v", value) 11283 } 11284 11285 var sv *types.FindingActor 11286 if *v == nil { 11287 sv = &types.FindingActor{} 11288 } else { 11289 sv = *v 11290 } 11291 11292 for key, value := range shape { 11293 switch key { 11294 case "domainDetails": 11295 if err := awsRestjson1_deserializeDocumentDomainDetails(&sv.DomainDetails, value); err != nil { 11296 return err 11297 } 11298 11299 case "ipAddressDetails": 11300 if err := awsRestjson1_deserializeDocumentIpAddressDetails(&sv.IpAddressDetails, value); err != nil { 11301 return err 11302 } 11303 11304 case "userIdentity": 11305 if err := awsRestjson1_deserializeDocumentUserIdentity(&sv.UserIdentity, value); err != nil { 11306 return err 11307 } 11308 11309 default: 11310 _, _ = key, value 11311 11312 } 11313 } 11314 *v = sv 11315 return nil 11316} 11317 11318func awsRestjson1_deserializeDocumentFindingCriteria(v **types.FindingCriteria, value interface{}) error { 11319 if v == nil { 11320 return fmt.Errorf("unexpected nil of type %T", v) 11321 } 11322 if value == nil { 11323 return nil 11324 } 11325 11326 shape, ok := value.(map[string]interface{}) 11327 if !ok { 11328 return fmt.Errorf("unexpected JSON type %v", value) 11329 } 11330 11331 var sv *types.FindingCriteria 11332 if *v == nil { 11333 sv = &types.FindingCriteria{} 11334 } else { 11335 sv = *v 11336 } 11337 11338 for key, value := range shape { 11339 switch key { 11340 case "criterion": 11341 if err := awsRestjson1_deserializeDocumentCriterion(&sv.Criterion, value); err != nil { 11342 return err 11343 } 11344 11345 default: 11346 _, _ = key, value 11347 11348 } 11349 } 11350 *v = sv 11351 return nil 11352} 11353 11354func awsRestjson1_deserializeDocumentFindingsFilterListItem(v **types.FindingsFilterListItem, value interface{}) error { 11355 if v == nil { 11356 return fmt.Errorf("unexpected nil of type %T", v) 11357 } 11358 if value == nil { 11359 return nil 11360 } 11361 11362 shape, ok := value.(map[string]interface{}) 11363 if !ok { 11364 return fmt.Errorf("unexpected JSON type %v", value) 11365 } 11366 11367 var sv *types.FindingsFilterListItem 11368 if *v == nil { 11369 sv = &types.FindingsFilterListItem{} 11370 } else { 11371 sv = *v 11372 } 11373 11374 for key, value := range shape { 11375 switch key { 11376 case "action": 11377 if value != nil { 11378 jtv, ok := value.(string) 11379 if !ok { 11380 return fmt.Errorf("expected FindingsFilterAction to be of type string, got %T instead", value) 11381 } 11382 sv.Action = types.FindingsFilterAction(jtv) 11383 } 11384 11385 case "arn": 11386 if value != nil { 11387 jtv, ok := value.(string) 11388 if !ok { 11389 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11390 } 11391 sv.Arn = ptr.String(jtv) 11392 } 11393 11394 case "id": 11395 if value != nil { 11396 jtv, ok := value.(string) 11397 if !ok { 11398 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11399 } 11400 sv.Id = ptr.String(jtv) 11401 } 11402 11403 case "name": 11404 if value != nil { 11405 jtv, ok := value.(string) 11406 if !ok { 11407 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11408 } 11409 sv.Name = ptr.String(jtv) 11410 } 11411 11412 case "tags": 11413 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 11414 return err 11415 } 11416 11417 default: 11418 _, _ = key, value 11419 11420 } 11421 } 11422 *v = sv 11423 return nil 11424} 11425 11426func awsRestjson1_deserializeDocumentGroupCount(v **types.GroupCount, value interface{}) error { 11427 if v == nil { 11428 return fmt.Errorf("unexpected nil of type %T", v) 11429 } 11430 if value == nil { 11431 return nil 11432 } 11433 11434 shape, ok := value.(map[string]interface{}) 11435 if !ok { 11436 return fmt.Errorf("unexpected JSON type %v", value) 11437 } 11438 11439 var sv *types.GroupCount 11440 if *v == nil { 11441 sv = &types.GroupCount{} 11442 } else { 11443 sv = *v 11444 } 11445 11446 for key, value := range shape { 11447 switch key { 11448 case "count": 11449 if value != nil { 11450 jtv, ok := value.(json.Number) 11451 if !ok { 11452 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11453 } 11454 i64, err := jtv.Int64() 11455 if err != nil { 11456 return err 11457 } 11458 sv.Count = i64 11459 } 11460 11461 case "groupKey": 11462 if value != nil { 11463 jtv, ok := value.(string) 11464 if !ok { 11465 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11466 } 11467 sv.GroupKey = ptr.String(jtv) 11468 } 11469 11470 default: 11471 _, _ = key, value 11472 11473 } 11474 } 11475 *v = sv 11476 return nil 11477} 11478 11479func awsRestjson1_deserializeDocumentIamUser(v **types.IamUser, value interface{}) error { 11480 if v == nil { 11481 return fmt.Errorf("unexpected nil of type %T", v) 11482 } 11483 if value == nil { 11484 return nil 11485 } 11486 11487 shape, ok := value.(map[string]interface{}) 11488 if !ok { 11489 return fmt.Errorf("unexpected JSON type %v", value) 11490 } 11491 11492 var sv *types.IamUser 11493 if *v == nil { 11494 sv = &types.IamUser{} 11495 } else { 11496 sv = *v 11497 } 11498 11499 for key, value := range shape { 11500 switch key { 11501 case "accountId": 11502 if value != nil { 11503 jtv, ok := value.(string) 11504 if !ok { 11505 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11506 } 11507 sv.AccountId = ptr.String(jtv) 11508 } 11509 11510 case "arn": 11511 if value != nil { 11512 jtv, ok := value.(string) 11513 if !ok { 11514 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11515 } 11516 sv.Arn = ptr.String(jtv) 11517 } 11518 11519 case "principalId": 11520 if value != nil { 11521 jtv, ok := value.(string) 11522 if !ok { 11523 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11524 } 11525 sv.PrincipalId = ptr.String(jtv) 11526 } 11527 11528 case "userName": 11529 if value != nil { 11530 jtv, ok := value.(string) 11531 if !ok { 11532 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11533 } 11534 sv.UserName = ptr.String(jtv) 11535 } 11536 11537 default: 11538 _, _ = key, value 11539 11540 } 11541 } 11542 *v = sv 11543 return nil 11544} 11545 11546func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { 11547 if v == nil { 11548 return fmt.Errorf("unexpected nil of type %T", v) 11549 } 11550 if value == nil { 11551 return nil 11552 } 11553 11554 shape, ok := value.(map[string]interface{}) 11555 if !ok { 11556 return fmt.Errorf("unexpected JSON type %v", value) 11557 } 11558 11559 var sv *types.InternalServerException 11560 if *v == nil { 11561 sv = &types.InternalServerException{} 11562 } else { 11563 sv = *v 11564 } 11565 11566 for key, value := range shape { 11567 switch key { 11568 case "message": 11569 if value != nil { 11570 jtv, ok := value.(string) 11571 if !ok { 11572 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11573 } 11574 sv.Message = ptr.String(jtv) 11575 } 11576 11577 default: 11578 _, _ = key, value 11579 11580 } 11581 } 11582 *v = sv 11583 return nil 11584} 11585 11586func awsRestjson1_deserializeDocumentInvitation(v **types.Invitation, value interface{}) error { 11587 if v == nil { 11588 return fmt.Errorf("unexpected nil of type %T", v) 11589 } 11590 if value == nil { 11591 return nil 11592 } 11593 11594 shape, ok := value.(map[string]interface{}) 11595 if !ok { 11596 return fmt.Errorf("unexpected JSON type %v", value) 11597 } 11598 11599 var sv *types.Invitation 11600 if *v == nil { 11601 sv = &types.Invitation{} 11602 } else { 11603 sv = *v 11604 } 11605 11606 for key, value := range shape { 11607 switch key { 11608 case "accountId": 11609 if value != nil { 11610 jtv, ok := value.(string) 11611 if !ok { 11612 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11613 } 11614 sv.AccountId = ptr.String(jtv) 11615 } 11616 11617 case "invitationId": 11618 if value != nil { 11619 jtv, ok := value.(string) 11620 if !ok { 11621 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11622 } 11623 sv.InvitationId = ptr.String(jtv) 11624 } 11625 11626 case "invitedAt": 11627 if value != nil { 11628 jtv, ok := value.(string) 11629 if !ok { 11630 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 11631 } 11632 t, err := smithytime.ParseDateTime(jtv) 11633 if err != nil { 11634 return err 11635 } 11636 sv.InvitedAt = ptr.Time(t) 11637 } 11638 11639 case "relationshipStatus": 11640 if value != nil { 11641 jtv, ok := value.(string) 11642 if !ok { 11643 return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value) 11644 } 11645 sv.RelationshipStatus = types.RelationshipStatus(jtv) 11646 } 11647 11648 default: 11649 _, _ = key, value 11650 11651 } 11652 } 11653 *v = sv 11654 return nil 11655} 11656 11657func awsRestjson1_deserializeDocumentIpAddressDetails(v **types.IpAddressDetails, value interface{}) error { 11658 if v == nil { 11659 return fmt.Errorf("unexpected nil of type %T", v) 11660 } 11661 if value == nil { 11662 return nil 11663 } 11664 11665 shape, ok := value.(map[string]interface{}) 11666 if !ok { 11667 return fmt.Errorf("unexpected JSON type %v", value) 11668 } 11669 11670 var sv *types.IpAddressDetails 11671 if *v == nil { 11672 sv = &types.IpAddressDetails{} 11673 } else { 11674 sv = *v 11675 } 11676 11677 for key, value := range shape { 11678 switch key { 11679 case "ipAddressV4": 11680 if value != nil { 11681 jtv, ok := value.(string) 11682 if !ok { 11683 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11684 } 11685 sv.IpAddressV4 = ptr.String(jtv) 11686 } 11687 11688 case "ipCity": 11689 if err := awsRestjson1_deserializeDocumentIpCity(&sv.IpCity, value); err != nil { 11690 return err 11691 } 11692 11693 case "ipCountry": 11694 if err := awsRestjson1_deserializeDocumentIpCountry(&sv.IpCountry, value); err != nil { 11695 return err 11696 } 11697 11698 case "ipGeoLocation": 11699 if err := awsRestjson1_deserializeDocumentIpGeoLocation(&sv.IpGeoLocation, value); err != nil { 11700 return err 11701 } 11702 11703 case "ipOwner": 11704 if err := awsRestjson1_deserializeDocumentIpOwner(&sv.IpOwner, value); err != nil { 11705 return err 11706 } 11707 11708 default: 11709 _, _ = key, value 11710 11711 } 11712 } 11713 *v = sv 11714 return nil 11715} 11716 11717func awsRestjson1_deserializeDocumentIpCity(v **types.IpCity, value interface{}) error { 11718 if v == nil { 11719 return fmt.Errorf("unexpected nil of type %T", v) 11720 } 11721 if value == nil { 11722 return nil 11723 } 11724 11725 shape, ok := value.(map[string]interface{}) 11726 if !ok { 11727 return fmt.Errorf("unexpected JSON type %v", value) 11728 } 11729 11730 var sv *types.IpCity 11731 if *v == nil { 11732 sv = &types.IpCity{} 11733 } else { 11734 sv = *v 11735 } 11736 11737 for key, value := range shape { 11738 switch key { 11739 case "name": 11740 if value != nil { 11741 jtv, ok := value.(string) 11742 if !ok { 11743 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11744 } 11745 sv.Name = ptr.String(jtv) 11746 } 11747 11748 default: 11749 _, _ = key, value 11750 11751 } 11752 } 11753 *v = sv 11754 return nil 11755} 11756 11757func awsRestjson1_deserializeDocumentIpCountry(v **types.IpCountry, value interface{}) error { 11758 if v == nil { 11759 return fmt.Errorf("unexpected nil of type %T", v) 11760 } 11761 if value == nil { 11762 return nil 11763 } 11764 11765 shape, ok := value.(map[string]interface{}) 11766 if !ok { 11767 return fmt.Errorf("unexpected JSON type %v", value) 11768 } 11769 11770 var sv *types.IpCountry 11771 if *v == nil { 11772 sv = &types.IpCountry{} 11773 } else { 11774 sv = *v 11775 } 11776 11777 for key, value := range shape { 11778 switch key { 11779 case "code": 11780 if value != nil { 11781 jtv, ok := value.(string) 11782 if !ok { 11783 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11784 } 11785 sv.Code = ptr.String(jtv) 11786 } 11787 11788 case "name": 11789 if value != nil { 11790 jtv, ok := value.(string) 11791 if !ok { 11792 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11793 } 11794 sv.Name = ptr.String(jtv) 11795 } 11796 11797 default: 11798 _, _ = key, value 11799 11800 } 11801 } 11802 *v = sv 11803 return nil 11804} 11805 11806func awsRestjson1_deserializeDocumentIpGeoLocation(v **types.IpGeoLocation, value interface{}) error { 11807 if v == nil { 11808 return fmt.Errorf("unexpected nil of type %T", v) 11809 } 11810 if value == nil { 11811 return nil 11812 } 11813 11814 shape, ok := value.(map[string]interface{}) 11815 if !ok { 11816 return fmt.Errorf("unexpected JSON type %v", value) 11817 } 11818 11819 var sv *types.IpGeoLocation 11820 if *v == nil { 11821 sv = &types.IpGeoLocation{} 11822 } else { 11823 sv = *v 11824 } 11825 11826 for key, value := range shape { 11827 switch key { 11828 case "lat": 11829 if value != nil { 11830 jtv, ok := value.(json.Number) 11831 if !ok { 11832 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 11833 } 11834 f64, err := jtv.Float64() 11835 if err != nil { 11836 return err 11837 } 11838 sv.Lat = f64 11839 } 11840 11841 case "lon": 11842 if value != nil { 11843 jtv, ok := value.(json.Number) 11844 if !ok { 11845 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 11846 } 11847 f64, err := jtv.Float64() 11848 if err != nil { 11849 return err 11850 } 11851 sv.Lon = f64 11852 } 11853 11854 default: 11855 _, _ = key, value 11856 11857 } 11858 } 11859 *v = sv 11860 return nil 11861} 11862 11863func awsRestjson1_deserializeDocumentIpOwner(v **types.IpOwner, value interface{}) error { 11864 if v == nil { 11865 return fmt.Errorf("unexpected nil of type %T", v) 11866 } 11867 if value == nil { 11868 return nil 11869 } 11870 11871 shape, ok := value.(map[string]interface{}) 11872 if !ok { 11873 return fmt.Errorf("unexpected JSON type %v", value) 11874 } 11875 11876 var sv *types.IpOwner 11877 if *v == nil { 11878 sv = &types.IpOwner{} 11879 } else { 11880 sv = *v 11881 } 11882 11883 for key, value := range shape { 11884 switch key { 11885 case "asn": 11886 if value != nil { 11887 jtv, ok := value.(string) 11888 if !ok { 11889 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11890 } 11891 sv.Asn = ptr.String(jtv) 11892 } 11893 11894 case "asnOrg": 11895 if value != nil { 11896 jtv, ok := value.(string) 11897 if !ok { 11898 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11899 } 11900 sv.AsnOrg = ptr.String(jtv) 11901 } 11902 11903 case "isp": 11904 if value != nil { 11905 jtv, ok := value.(string) 11906 if !ok { 11907 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11908 } 11909 sv.Isp = ptr.String(jtv) 11910 } 11911 11912 case "org": 11913 if value != nil { 11914 jtv, ok := value.(string) 11915 if !ok { 11916 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11917 } 11918 sv.Org = ptr.String(jtv) 11919 } 11920 11921 default: 11922 _, _ = key, value 11923 11924 } 11925 } 11926 *v = sv 11927 return nil 11928} 11929 11930func awsRestjson1_deserializeDocumentJobDetails(v **types.JobDetails, value interface{}) error { 11931 if v == nil { 11932 return fmt.Errorf("unexpected nil of type %T", v) 11933 } 11934 if value == nil { 11935 return nil 11936 } 11937 11938 shape, ok := value.(map[string]interface{}) 11939 if !ok { 11940 return fmt.Errorf("unexpected JSON type %v", value) 11941 } 11942 11943 var sv *types.JobDetails 11944 if *v == nil { 11945 sv = &types.JobDetails{} 11946 } else { 11947 sv = *v 11948 } 11949 11950 for key, value := range shape { 11951 switch key { 11952 case "isDefinedInJob": 11953 if value != nil { 11954 jtv, ok := value.(string) 11955 if !ok { 11956 return fmt.Errorf("expected IsDefinedInJob to be of type string, got %T instead", value) 11957 } 11958 sv.IsDefinedInJob = types.IsDefinedInJob(jtv) 11959 } 11960 11961 case "isMonitoredByJob": 11962 if value != nil { 11963 jtv, ok := value.(string) 11964 if !ok { 11965 return fmt.Errorf("expected IsMonitoredByJob to be of type string, got %T instead", value) 11966 } 11967 sv.IsMonitoredByJob = types.IsMonitoredByJob(jtv) 11968 } 11969 11970 case "lastJobId": 11971 if value != nil { 11972 jtv, ok := value.(string) 11973 if !ok { 11974 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11975 } 11976 sv.LastJobId = ptr.String(jtv) 11977 } 11978 11979 case "lastJobRunTime": 11980 if value != nil { 11981 jtv, ok := value.(string) 11982 if !ok { 11983 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 11984 } 11985 t, err := smithytime.ParseDateTime(jtv) 11986 if err != nil { 11987 return err 11988 } 11989 sv.LastJobRunTime = ptr.Time(t) 11990 } 11991 11992 default: 11993 _, _ = key, value 11994 11995 } 11996 } 11997 *v = sv 11998 return nil 11999} 12000 12001func awsRestjson1_deserializeDocumentJobScheduleFrequency(v **types.JobScheduleFrequency, value interface{}) error { 12002 if v == nil { 12003 return fmt.Errorf("unexpected nil of type %T", v) 12004 } 12005 if value == nil { 12006 return nil 12007 } 12008 12009 shape, ok := value.(map[string]interface{}) 12010 if !ok { 12011 return fmt.Errorf("unexpected JSON type %v", value) 12012 } 12013 12014 var sv *types.JobScheduleFrequency 12015 if *v == nil { 12016 sv = &types.JobScheduleFrequency{} 12017 } else { 12018 sv = *v 12019 } 12020 12021 for key, value := range shape { 12022 switch key { 12023 case "dailySchedule": 12024 if err := awsRestjson1_deserializeDocumentDailySchedule(&sv.DailySchedule, value); err != nil { 12025 return err 12026 } 12027 12028 case "monthlySchedule": 12029 if err := awsRestjson1_deserializeDocumentMonthlySchedule(&sv.MonthlySchedule, value); err != nil { 12030 return err 12031 } 12032 12033 case "weeklySchedule": 12034 if err := awsRestjson1_deserializeDocumentWeeklySchedule(&sv.WeeklySchedule, value); err != nil { 12035 return err 12036 } 12037 12038 default: 12039 _, _ = key, value 12040 12041 } 12042 } 12043 *v = sv 12044 return nil 12045} 12046 12047func awsRestjson1_deserializeDocumentJobScopeTerm(v **types.JobScopeTerm, value interface{}) error { 12048 if v == nil { 12049 return fmt.Errorf("unexpected nil of type %T", v) 12050 } 12051 if value == nil { 12052 return nil 12053 } 12054 12055 shape, ok := value.(map[string]interface{}) 12056 if !ok { 12057 return fmt.Errorf("unexpected JSON type %v", value) 12058 } 12059 12060 var sv *types.JobScopeTerm 12061 if *v == nil { 12062 sv = &types.JobScopeTerm{} 12063 } else { 12064 sv = *v 12065 } 12066 12067 for key, value := range shape { 12068 switch key { 12069 case "simpleScopeTerm": 12070 if err := awsRestjson1_deserializeDocumentSimpleScopeTerm(&sv.SimpleScopeTerm, value); err != nil { 12071 return err 12072 } 12073 12074 case "tagScopeTerm": 12075 if err := awsRestjson1_deserializeDocumentTagScopeTerm(&sv.TagScopeTerm, value); err != nil { 12076 return err 12077 } 12078 12079 default: 12080 _, _ = key, value 12081 12082 } 12083 } 12084 *v = sv 12085 return nil 12086} 12087 12088func awsRestjson1_deserializeDocumentJobScopingBlock(v **types.JobScopingBlock, value interface{}) error { 12089 if v == nil { 12090 return fmt.Errorf("unexpected nil of type %T", v) 12091 } 12092 if value == nil { 12093 return nil 12094 } 12095 12096 shape, ok := value.(map[string]interface{}) 12097 if !ok { 12098 return fmt.Errorf("unexpected JSON type %v", value) 12099 } 12100 12101 var sv *types.JobScopingBlock 12102 if *v == nil { 12103 sv = &types.JobScopingBlock{} 12104 } else { 12105 sv = *v 12106 } 12107 12108 for key, value := range shape { 12109 switch key { 12110 case "and": 12111 if err := awsRestjson1_deserializeDocument__listOfJobScopeTerm(&sv.And, value); err != nil { 12112 return err 12113 } 12114 12115 default: 12116 _, _ = key, value 12117 12118 } 12119 } 12120 *v = sv 12121 return nil 12122} 12123 12124func awsRestjson1_deserializeDocumentJobSummary(v **types.JobSummary, value interface{}) error { 12125 if v == nil { 12126 return fmt.Errorf("unexpected nil of type %T", v) 12127 } 12128 if value == nil { 12129 return nil 12130 } 12131 12132 shape, ok := value.(map[string]interface{}) 12133 if !ok { 12134 return fmt.Errorf("unexpected JSON type %v", value) 12135 } 12136 12137 var sv *types.JobSummary 12138 if *v == nil { 12139 sv = &types.JobSummary{} 12140 } else { 12141 sv = *v 12142 } 12143 12144 for key, value := range shape { 12145 switch key { 12146 case "bucketDefinitions": 12147 if err := awsRestjson1_deserializeDocument__listOfS3BucketDefinitionForJob(&sv.BucketDefinitions, value); err != nil { 12148 return err 12149 } 12150 12151 case "createdAt": 12152 if value != nil { 12153 jtv, ok := value.(string) 12154 if !ok { 12155 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 12156 } 12157 t, err := smithytime.ParseDateTime(jtv) 12158 if err != nil { 12159 return err 12160 } 12161 sv.CreatedAt = ptr.Time(t) 12162 } 12163 12164 case "jobId": 12165 if value != nil { 12166 jtv, ok := value.(string) 12167 if !ok { 12168 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12169 } 12170 sv.JobId = ptr.String(jtv) 12171 } 12172 12173 case "jobStatus": 12174 if value != nil { 12175 jtv, ok := value.(string) 12176 if !ok { 12177 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 12178 } 12179 sv.JobStatus = types.JobStatus(jtv) 12180 } 12181 12182 case "jobType": 12183 if value != nil { 12184 jtv, ok := value.(string) 12185 if !ok { 12186 return fmt.Errorf("expected JobType to be of type string, got %T instead", value) 12187 } 12188 sv.JobType = types.JobType(jtv) 12189 } 12190 12191 case "lastRunErrorStatus": 12192 if err := awsRestjson1_deserializeDocumentLastRunErrorStatus(&sv.LastRunErrorStatus, value); err != nil { 12193 return err 12194 } 12195 12196 case "name": 12197 if value != nil { 12198 jtv, ok := value.(string) 12199 if !ok { 12200 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12201 } 12202 sv.Name = ptr.String(jtv) 12203 } 12204 12205 case "userPausedDetails": 12206 if err := awsRestjson1_deserializeDocumentUserPausedDetails(&sv.UserPausedDetails, value); err != nil { 12207 return err 12208 } 12209 12210 default: 12211 _, _ = key, value 12212 12213 } 12214 } 12215 *v = sv 12216 return nil 12217} 12218 12219func awsRestjson1_deserializeDocumentKeyValuePair(v **types.KeyValuePair, value interface{}) error { 12220 if v == nil { 12221 return fmt.Errorf("unexpected nil of type %T", v) 12222 } 12223 if value == nil { 12224 return nil 12225 } 12226 12227 shape, ok := value.(map[string]interface{}) 12228 if !ok { 12229 return fmt.Errorf("unexpected JSON type %v", value) 12230 } 12231 12232 var sv *types.KeyValuePair 12233 if *v == nil { 12234 sv = &types.KeyValuePair{} 12235 } else { 12236 sv = *v 12237 } 12238 12239 for key, value := range shape { 12240 switch key { 12241 case "key": 12242 if value != nil { 12243 jtv, ok := value.(string) 12244 if !ok { 12245 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12246 } 12247 sv.Key = ptr.String(jtv) 12248 } 12249 12250 case "value": 12251 if value != nil { 12252 jtv, ok := value.(string) 12253 if !ok { 12254 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12255 } 12256 sv.Value = ptr.String(jtv) 12257 } 12258 12259 default: 12260 _, _ = key, value 12261 12262 } 12263 } 12264 *v = sv 12265 return nil 12266} 12267 12268func awsRestjson1_deserializeDocumentKeyValuePairList(v *[]types.KeyValuePair, value interface{}) error { 12269 if v == nil { 12270 return fmt.Errorf("unexpected nil of type %T", v) 12271 } 12272 if value == nil { 12273 return nil 12274 } 12275 12276 shape, ok := value.([]interface{}) 12277 if !ok { 12278 return fmt.Errorf("unexpected JSON type %v", value) 12279 } 12280 12281 var cv []types.KeyValuePair 12282 if *v == nil { 12283 cv = []types.KeyValuePair{} 12284 } else { 12285 cv = *v 12286 } 12287 12288 for _, value := range shape { 12289 var col types.KeyValuePair 12290 destAddr := &col 12291 if err := awsRestjson1_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 12292 return err 12293 } 12294 col = *destAddr 12295 cv = append(cv, col) 12296 12297 } 12298 *v = cv 12299 return nil 12300} 12301 12302func awsRestjson1_deserializeDocumentLastRunErrorStatus(v **types.LastRunErrorStatus, value interface{}) error { 12303 if v == nil { 12304 return fmt.Errorf("unexpected nil of type %T", v) 12305 } 12306 if value == nil { 12307 return nil 12308 } 12309 12310 shape, ok := value.(map[string]interface{}) 12311 if !ok { 12312 return fmt.Errorf("unexpected JSON type %v", value) 12313 } 12314 12315 var sv *types.LastRunErrorStatus 12316 if *v == nil { 12317 sv = &types.LastRunErrorStatus{} 12318 } else { 12319 sv = *v 12320 } 12321 12322 for key, value := range shape { 12323 switch key { 12324 case "code": 12325 if value != nil { 12326 jtv, ok := value.(string) 12327 if !ok { 12328 return fmt.Errorf("expected LastRunErrorStatusCode to be of type string, got %T instead", value) 12329 } 12330 sv.Code = types.LastRunErrorStatusCode(jtv) 12331 } 12332 12333 default: 12334 _, _ = key, value 12335 12336 } 12337 } 12338 *v = sv 12339 return nil 12340} 12341 12342func awsRestjson1_deserializeDocumentMember(v **types.Member, value interface{}) error { 12343 if v == nil { 12344 return fmt.Errorf("unexpected nil of type %T", v) 12345 } 12346 if value == nil { 12347 return nil 12348 } 12349 12350 shape, ok := value.(map[string]interface{}) 12351 if !ok { 12352 return fmt.Errorf("unexpected JSON type %v", value) 12353 } 12354 12355 var sv *types.Member 12356 if *v == nil { 12357 sv = &types.Member{} 12358 } else { 12359 sv = *v 12360 } 12361 12362 for key, value := range shape { 12363 switch key { 12364 case "accountId": 12365 if value != nil { 12366 jtv, ok := value.(string) 12367 if !ok { 12368 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12369 } 12370 sv.AccountId = ptr.String(jtv) 12371 } 12372 12373 case "arn": 12374 if value != nil { 12375 jtv, ok := value.(string) 12376 if !ok { 12377 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12378 } 12379 sv.Arn = ptr.String(jtv) 12380 } 12381 12382 case "email": 12383 if value != nil { 12384 jtv, ok := value.(string) 12385 if !ok { 12386 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12387 } 12388 sv.Email = ptr.String(jtv) 12389 } 12390 12391 case "invitedAt": 12392 if value != nil { 12393 jtv, ok := value.(string) 12394 if !ok { 12395 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 12396 } 12397 t, err := smithytime.ParseDateTime(jtv) 12398 if err != nil { 12399 return err 12400 } 12401 sv.InvitedAt = ptr.Time(t) 12402 } 12403 12404 case "masterAccountId": 12405 if value != nil { 12406 jtv, ok := value.(string) 12407 if !ok { 12408 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12409 } 12410 sv.MasterAccountId = ptr.String(jtv) 12411 } 12412 12413 case "relationshipStatus": 12414 if value != nil { 12415 jtv, ok := value.(string) 12416 if !ok { 12417 return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value) 12418 } 12419 sv.RelationshipStatus = types.RelationshipStatus(jtv) 12420 } 12421 12422 case "tags": 12423 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 12424 return err 12425 } 12426 12427 case "updatedAt": 12428 if value != nil { 12429 jtv, ok := value.(string) 12430 if !ok { 12431 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 12432 } 12433 t, err := smithytime.ParseDateTime(jtv) 12434 if err != nil { 12435 return err 12436 } 12437 sv.UpdatedAt = ptr.Time(t) 12438 } 12439 12440 default: 12441 _, _ = key, value 12442 12443 } 12444 } 12445 *v = sv 12446 return nil 12447} 12448 12449func awsRestjson1_deserializeDocumentMonthlySchedule(v **types.MonthlySchedule, value interface{}) error { 12450 if v == nil { 12451 return fmt.Errorf("unexpected nil of type %T", v) 12452 } 12453 if value == nil { 12454 return nil 12455 } 12456 12457 shape, ok := value.(map[string]interface{}) 12458 if !ok { 12459 return fmt.Errorf("unexpected JSON type %v", value) 12460 } 12461 12462 var sv *types.MonthlySchedule 12463 if *v == nil { 12464 sv = &types.MonthlySchedule{} 12465 } else { 12466 sv = *v 12467 } 12468 12469 for key, value := range shape { 12470 switch key { 12471 case "dayOfMonth": 12472 if value != nil { 12473 jtv, ok := value.(json.Number) 12474 if !ok { 12475 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 12476 } 12477 i64, err := jtv.Int64() 12478 if err != nil { 12479 return err 12480 } 12481 sv.DayOfMonth = int32(i64) 12482 } 12483 12484 default: 12485 _, _ = key, value 12486 12487 } 12488 } 12489 *v = sv 12490 return nil 12491} 12492 12493func awsRestjson1_deserializeDocumentObjectCountByEncryptionType(v **types.ObjectCountByEncryptionType, value interface{}) error { 12494 if v == nil { 12495 return fmt.Errorf("unexpected nil of type %T", v) 12496 } 12497 if value == nil { 12498 return nil 12499 } 12500 12501 shape, ok := value.(map[string]interface{}) 12502 if !ok { 12503 return fmt.Errorf("unexpected JSON type %v", value) 12504 } 12505 12506 var sv *types.ObjectCountByEncryptionType 12507 if *v == nil { 12508 sv = &types.ObjectCountByEncryptionType{} 12509 } else { 12510 sv = *v 12511 } 12512 12513 for key, value := range shape { 12514 switch key { 12515 case "customerManaged": 12516 if value != nil { 12517 jtv, ok := value.(json.Number) 12518 if !ok { 12519 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12520 } 12521 i64, err := jtv.Int64() 12522 if err != nil { 12523 return err 12524 } 12525 sv.CustomerManaged = i64 12526 } 12527 12528 case "kmsManaged": 12529 if value != nil { 12530 jtv, ok := value.(json.Number) 12531 if !ok { 12532 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12533 } 12534 i64, err := jtv.Int64() 12535 if err != nil { 12536 return err 12537 } 12538 sv.KmsManaged = i64 12539 } 12540 12541 case "s3Managed": 12542 if value != nil { 12543 jtv, ok := value.(json.Number) 12544 if !ok { 12545 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12546 } 12547 i64, err := jtv.Int64() 12548 if err != nil { 12549 return err 12550 } 12551 sv.S3Managed = i64 12552 } 12553 12554 case "unencrypted": 12555 if value != nil { 12556 jtv, ok := value.(json.Number) 12557 if !ok { 12558 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12559 } 12560 i64, err := jtv.Int64() 12561 if err != nil { 12562 return err 12563 } 12564 sv.Unencrypted = i64 12565 } 12566 12567 default: 12568 _, _ = key, value 12569 12570 } 12571 } 12572 *v = sv 12573 return nil 12574} 12575 12576func awsRestjson1_deserializeDocumentObjectLevelStatistics(v **types.ObjectLevelStatistics, value interface{}) error { 12577 if v == nil { 12578 return fmt.Errorf("unexpected nil of type %T", v) 12579 } 12580 if value == nil { 12581 return nil 12582 } 12583 12584 shape, ok := value.(map[string]interface{}) 12585 if !ok { 12586 return fmt.Errorf("unexpected JSON type %v", value) 12587 } 12588 12589 var sv *types.ObjectLevelStatistics 12590 if *v == nil { 12591 sv = &types.ObjectLevelStatistics{} 12592 } else { 12593 sv = *v 12594 } 12595 12596 for key, value := range shape { 12597 switch key { 12598 case "fileType": 12599 if value != nil { 12600 jtv, ok := value.(json.Number) 12601 if !ok { 12602 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12603 } 12604 i64, err := jtv.Int64() 12605 if err != nil { 12606 return err 12607 } 12608 sv.FileType = i64 12609 } 12610 12611 case "storageClass": 12612 if value != nil { 12613 jtv, ok := value.(json.Number) 12614 if !ok { 12615 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12616 } 12617 i64, err := jtv.Int64() 12618 if err != nil { 12619 return err 12620 } 12621 sv.StorageClass = i64 12622 } 12623 12624 case "total": 12625 if value != nil { 12626 jtv, ok := value.(json.Number) 12627 if !ok { 12628 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12629 } 12630 i64, err := jtv.Int64() 12631 if err != nil { 12632 return err 12633 } 12634 sv.Total = i64 12635 } 12636 12637 default: 12638 _, _ = key, value 12639 12640 } 12641 } 12642 *v = sv 12643 return nil 12644} 12645 12646func awsRestjson1_deserializeDocumentOccurrences(v **types.Occurrences, value interface{}) error { 12647 if v == nil { 12648 return fmt.Errorf("unexpected nil of type %T", v) 12649 } 12650 if value == nil { 12651 return nil 12652 } 12653 12654 shape, ok := value.(map[string]interface{}) 12655 if !ok { 12656 return fmt.Errorf("unexpected JSON type %v", value) 12657 } 12658 12659 var sv *types.Occurrences 12660 if *v == nil { 12661 sv = &types.Occurrences{} 12662 } else { 12663 sv = *v 12664 } 12665 12666 for key, value := range shape { 12667 switch key { 12668 case "cells": 12669 if err := awsRestjson1_deserializeDocumentCells(&sv.Cells, value); err != nil { 12670 return err 12671 } 12672 12673 case "lineRanges": 12674 if err := awsRestjson1_deserializeDocumentRanges(&sv.LineRanges, value); err != nil { 12675 return err 12676 } 12677 12678 case "offsetRanges": 12679 if err := awsRestjson1_deserializeDocumentRanges(&sv.OffsetRanges, value); err != nil { 12680 return err 12681 } 12682 12683 case "pages": 12684 if err := awsRestjson1_deserializeDocumentPages(&sv.Pages, value); err != nil { 12685 return err 12686 } 12687 12688 case "records": 12689 if err := awsRestjson1_deserializeDocumentRecords(&sv.Records, value); err != nil { 12690 return err 12691 } 12692 12693 default: 12694 _, _ = key, value 12695 12696 } 12697 } 12698 *v = sv 12699 return nil 12700} 12701 12702func awsRestjson1_deserializeDocumentPage(v **types.Page, value interface{}) error { 12703 if v == nil { 12704 return fmt.Errorf("unexpected nil of type %T", v) 12705 } 12706 if value == nil { 12707 return nil 12708 } 12709 12710 shape, ok := value.(map[string]interface{}) 12711 if !ok { 12712 return fmt.Errorf("unexpected JSON type %v", value) 12713 } 12714 12715 var sv *types.Page 12716 if *v == nil { 12717 sv = &types.Page{} 12718 } else { 12719 sv = *v 12720 } 12721 12722 for key, value := range shape { 12723 switch key { 12724 case "lineRange": 12725 if err := awsRestjson1_deserializeDocumentRange(&sv.LineRange, value); err != nil { 12726 return err 12727 } 12728 12729 case "offsetRange": 12730 if err := awsRestjson1_deserializeDocumentRange(&sv.OffsetRange, value); err != nil { 12731 return err 12732 } 12733 12734 case "pageNumber": 12735 if value != nil { 12736 jtv, ok := value.(json.Number) 12737 if !ok { 12738 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12739 } 12740 i64, err := jtv.Int64() 12741 if err != nil { 12742 return err 12743 } 12744 sv.PageNumber = i64 12745 } 12746 12747 default: 12748 _, _ = key, value 12749 12750 } 12751 } 12752 *v = sv 12753 return nil 12754} 12755 12756func awsRestjson1_deserializeDocumentPages(v *[]types.Page, value interface{}) error { 12757 if v == nil { 12758 return fmt.Errorf("unexpected nil of type %T", v) 12759 } 12760 if value == nil { 12761 return nil 12762 } 12763 12764 shape, ok := value.([]interface{}) 12765 if !ok { 12766 return fmt.Errorf("unexpected JSON type %v", value) 12767 } 12768 12769 var cv []types.Page 12770 if *v == nil { 12771 cv = []types.Page{} 12772 } else { 12773 cv = *v 12774 } 12775 12776 for _, value := range shape { 12777 var col types.Page 12778 destAddr := &col 12779 if err := awsRestjson1_deserializeDocumentPage(&destAddr, value); err != nil { 12780 return err 12781 } 12782 col = *destAddr 12783 cv = append(cv, col) 12784 12785 } 12786 *v = cv 12787 return nil 12788} 12789 12790func awsRestjson1_deserializeDocumentPolicyDetails(v **types.PolicyDetails, value interface{}) error { 12791 if v == nil { 12792 return fmt.Errorf("unexpected nil of type %T", v) 12793 } 12794 if value == nil { 12795 return nil 12796 } 12797 12798 shape, ok := value.(map[string]interface{}) 12799 if !ok { 12800 return fmt.Errorf("unexpected JSON type %v", value) 12801 } 12802 12803 var sv *types.PolicyDetails 12804 if *v == nil { 12805 sv = &types.PolicyDetails{} 12806 } else { 12807 sv = *v 12808 } 12809 12810 for key, value := range shape { 12811 switch key { 12812 case "action": 12813 if err := awsRestjson1_deserializeDocumentFindingAction(&sv.Action, value); err != nil { 12814 return err 12815 } 12816 12817 case "actor": 12818 if err := awsRestjson1_deserializeDocumentFindingActor(&sv.Actor, value); err != nil { 12819 return err 12820 } 12821 12822 default: 12823 _, _ = key, value 12824 12825 } 12826 } 12827 *v = sv 12828 return nil 12829} 12830 12831func awsRestjson1_deserializeDocumentRange(v **types.Range, value interface{}) error { 12832 if v == nil { 12833 return fmt.Errorf("unexpected nil of type %T", v) 12834 } 12835 if value == nil { 12836 return nil 12837 } 12838 12839 shape, ok := value.(map[string]interface{}) 12840 if !ok { 12841 return fmt.Errorf("unexpected JSON type %v", value) 12842 } 12843 12844 var sv *types.Range 12845 if *v == nil { 12846 sv = &types.Range{} 12847 } else { 12848 sv = *v 12849 } 12850 12851 for key, value := range shape { 12852 switch key { 12853 case "end": 12854 if value != nil { 12855 jtv, ok := value.(json.Number) 12856 if !ok { 12857 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12858 } 12859 i64, err := jtv.Int64() 12860 if err != nil { 12861 return err 12862 } 12863 sv.End = i64 12864 } 12865 12866 case "start": 12867 if value != nil { 12868 jtv, ok := value.(json.Number) 12869 if !ok { 12870 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12871 } 12872 i64, err := jtv.Int64() 12873 if err != nil { 12874 return err 12875 } 12876 sv.Start = i64 12877 } 12878 12879 case "startColumn": 12880 if value != nil { 12881 jtv, ok := value.(json.Number) 12882 if !ok { 12883 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12884 } 12885 i64, err := jtv.Int64() 12886 if err != nil { 12887 return err 12888 } 12889 sv.StartColumn = i64 12890 } 12891 12892 default: 12893 _, _ = key, value 12894 12895 } 12896 } 12897 *v = sv 12898 return nil 12899} 12900 12901func awsRestjson1_deserializeDocumentRanges(v *[]types.Range, value interface{}) error { 12902 if v == nil { 12903 return fmt.Errorf("unexpected nil of type %T", v) 12904 } 12905 if value == nil { 12906 return nil 12907 } 12908 12909 shape, ok := value.([]interface{}) 12910 if !ok { 12911 return fmt.Errorf("unexpected JSON type %v", value) 12912 } 12913 12914 var cv []types.Range 12915 if *v == nil { 12916 cv = []types.Range{} 12917 } else { 12918 cv = *v 12919 } 12920 12921 for _, value := range shape { 12922 var col types.Range 12923 destAddr := &col 12924 if err := awsRestjson1_deserializeDocumentRange(&destAddr, value); err != nil { 12925 return err 12926 } 12927 col = *destAddr 12928 cv = append(cv, col) 12929 12930 } 12931 *v = cv 12932 return nil 12933} 12934 12935func awsRestjson1_deserializeDocumentRecord(v **types.Record, value interface{}) error { 12936 if v == nil { 12937 return fmt.Errorf("unexpected nil of type %T", v) 12938 } 12939 if value == nil { 12940 return nil 12941 } 12942 12943 shape, ok := value.(map[string]interface{}) 12944 if !ok { 12945 return fmt.Errorf("unexpected JSON type %v", value) 12946 } 12947 12948 var sv *types.Record 12949 if *v == nil { 12950 sv = &types.Record{} 12951 } else { 12952 sv = *v 12953 } 12954 12955 for key, value := range shape { 12956 switch key { 12957 case "jsonPath": 12958 if value != nil { 12959 jtv, ok := value.(string) 12960 if !ok { 12961 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12962 } 12963 sv.JsonPath = ptr.String(jtv) 12964 } 12965 12966 case "recordIndex": 12967 if value != nil { 12968 jtv, ok := value.(json.Number) 12969 if !ok { 12970 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12971 } 12972 i64, err := jtv.Int64() 12973 if err != nil { 12974 return err 12975 } 12976 sv.RecordIndex = i64 12977 } 12978 12979 default: 12980 _, _ = key, value 12981 12982 } 12983 } 12984 *v = sv 12985 return nil 12986} 12987 12988func awsRestjson1_deserializeDocumentRecords(v *[]types.Record, value interface{}) error { 12989 if v == nil { 12990 return fmt.Errorf("unexpected nil of type %T", v) 12991 } 12992 if value == nil { 12993 return nil 12994 } 12995 12996 shape, ok := value.([]interface{}) 12997 if !ok { 12998 return fmt.Errorf("unexpected JSON type %v", value) 12999 } 13000 13001 var cv []types.Record 13002 if *v == nil { 13003 cv = []types.Record{} 13004 } else { 13005 cv = *v 13006 } 13007 13008 for _, value := range shape { 13009 var col types.Record 13010 destAddr := &col 13011 if err := awsRestjson1_deserializeDocumentRecord(&destAddr, value); err != nil { 13012 return err 13013 } 13014 col = *destAddr 13015 cv = append(cv, col) 13016 13017 } 13018 *v = cv 13019 return nil 13020} 13021 13022func awsRestjson1_deserializeDocumentReplicationDetails(v **types.ReplicationDetails, value interface{}) error { 13023 if v == nil { 13024 return fmt.Errorf("unexpected nil of type %T", v) 13025 } 13026 if value == nil { 13027 return nil 13028 } 13029 13030 shape, ok := value.(map[string]interface{}) 13031 if !ok { 13032 return fmt.Errorf("unexpected JSON type %v", value) 13033 } 13034 13035 var sv *types.ReplicationDetails 13036 if *v == nil { 13037 sv = &types.ReplicationDetails{} 13038 } else { 13039 sv = *v 13040 } 13041 13042 for key, value := range shape { 13043 switch key { 13044 case "replicated": 13045 if value != nil { 13046 jtv, ok := value.(bool) 13047 if !ok { 13048 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 13049 } 13050 sv.Replicated = jtv 13051 } 13052 13053 case "replicatedExternally": 13054 if value != nil { 13055 jtv, ok := value.(bool) 13056 if !ok { 13057 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 13058 } 13059 sv.ReplicatedExternally = jtv 13060 } 13061 13062 case "replicationAccounts": 13063 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.ReplicationAccounts, value); err != nil { 13064 return err 13065 } 13066 13067 default: 13068 _, _ = key, value 13069 13070 } 13071 } 13072 *v = sv 13073 return nil 13074} 13075 13076func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 13077 if v == nil { 13078 return fmt.Errorf("unexpected nil of type %T", v) 13079 } 13080 if value == nil { 13081 return nil 13082 } 13083 13084 shape, ok := value.(map[string]interface{}) 13085 if !ok { 13086 return fmt.Errorf("unexpected JSON type %v", value) 13087 } 13088 13089 var sv *types.ResourceNotFoundException 13090 if *v == nil { 13091 sv = &types.ResourceNotFoundException{} 13092 } else { 13093 sv = *v 13094 } 13095 13096 for key, value := range shape { 13097 switch key { 13098 case "message": 13099 if value != nil { 13100 jtv, ok := value.(string) 13101 if !ok { 13102 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13103 } 13104 sv.Message = ptr.String(jtv) 13105 } 13106 13107 default: 13108 _, _ = key, value 13109 13110 } 13111 } 13112 *v = sv 13113 return nil 13114} 13115 13116func awsRestjson1_deserializeDocumentResourcesAffected(v **types.ResourcesAffected, value interface{}) error { 13117 if v == nil { 13118 return fmt.Errorf("unexpected nil of type %T", v) 13119 } 13120 if value == nil { 13121 return nil 13122 } 13123 13124 shape, ok := value.(map[string]interface{}) 13125 if !ok { 13126 return fmt.Errorf("unexpected JSON type %v", value) 13127 } 13128 13129 var sv *types.ResourcesAffected 13130 if *v == nil { 13131 sv = &types.ResourcesAffected{} 13132 } else { 13133 sv = *v 13134 } 13135 13136 for key, value := range shape { 13137 switch key { 13138 case "s3Bucket": 13139 if err := awsRestjson1_deserializeDocumentS3Bucket(&sv.S3Bucket, value); err != nil { 13140 return err 13141 } 13142 13143 case "s3Object": 13144 if err := awsRestjson1_deserializeDocumentS3Object(&sv.S3Object, value); err != nil { 13145 return err 13146 } 13147 13148 default: 13149 _, _ = key, value 13150 13151 } 13152 } 13153 *v = sv 13154 return nil 13155} 13156 13157func awsRestjson1_deserializeDocumentS3Bucket(v **types.S3Bucket, value interface{}) error { 13158 if v == nil { 13159 return fmt.Errorf("unexpected nil of type %T", v) 13160 } 13161 if value == nil { 13162 return nil 13163 } 13164 13165 shape, ok := value.(map[string]interface{}) 13166 if !ok { 13167 return fmt.Errorf("unexpected JSON type %v", value) 13168 } 13169 13170 var sv *types.S3Bucket 13171 if *v == nil { 13172 sv = &types.S3Bucket{} 13173 } else { 13174 sv = *v 13175 } 13176 13177 for key, value := range shape { 13178 switch key { 13179 case "arn": 13180 if value != nil { 13181 jtv, ok := value.(string) 13182 if !ok { 13183 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13184 } 13185 sv.Arn = ptr.String(jtv) 13186 } 13187 13188 case "createdAt": 13189 if value != nil { 13190 jtv, ok := value.(string) 13191 if !ok { 13192 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 13193 } 13194 t, err := smithytime.ParseDateTime(jtv) 13195 if err != nil { 13196 return err 13197 } 13198 sv.CreatedAt = ptr.Time(t) 13199 } 13200 13201 case "defaultServerSideEncryption": 13202 if err := awsRestjson1_deserializeDocumentServerSideEncryption(&sv.DefaultServerSideEncryption, value); err != nil { 13203 return err 13204 } 13205 13206 case "name": 13207 if value != nil { 13208 jtv, ok := value.(string) 13209 if !ok { 13210 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13211 } 13212 sv.Name = ptr.String(jtv) 13213 } 13214 13215 case "owner": 13216 if err := awsRestjson1_deserializeDocumentS3BucketOwner(&sv.Owner, value); err != nil { 13217 return err 13218 } 13219 13220 case "publicAccess": 13221 if err := awsRestjson1_deserializeDocumentBucketPublicAccess(&sv.PublicAccess, value); err != nil { 13222 return err 13223 } 13224 13225 case "tags": 13226 if err := awsRestjson1_deserializeDocumentKeyValuePairList(&sv.Tags, value); err != nil { 13227 return err 13228 } 13229 13230 default: 13231 _, _ = key, value 13232 13233 } 13234 } 13235 *v = sv 13236 return nil 13237} 13238 13239func awsRestjson1_deserializeDocumentS3BucketDefinitionForJob(v **types.S3BucketDefinitionForJob, value interface{}) error { 13240 if v == nil { 13241 return fmt.Errorf("unexpected nil of type %T", v) 13242 } 13243 if value == nil { 13244 return nil 13245 } 13246 13247 shape, ok := value.(map[string]interface{}) 13248 if !ok { 13249 return fmt.Errorf("unexpected JSON type %v", value) 13250 } 13251 13252 var sv *types.S3BucketDefinitionForJob 13253 if *v == nil { 13254 sv = &types.S3BucketDefinitionForJob{} 13255 } else { 13256 sv = *v 13257 } 13258 13259 for key, value := range shape { 13260 switch key { 13261 case "accountId": 13262 if value != nil { 13263 jtv, ok := value.(string) 13264 if !ok { 13265 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13266 } 13267 sv.AccountId = ptr.String(jtv) 13268 } 13269 13270 case "buckets": 13271 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Buckets, value); err != nil { 13272 return err 13273 } 13274 13275 default: 13276 _, _ = key, value 13277 13278 } 13279 } 13280 *v = sv 13281 return nil 13282} 13283 13284func awsRestjson1_deserializeDocumentS3BucketOwner(v **types.S3BucketOwner, value interface{}) error { 13285 if v == nil { 13286 return fmt.Errorf("unexpected nil of type %T", v) 13287 } 13288 if value == nil { 13289 return nil 13290 } 13291 13292 shape, ok := value.(map[string]interface{}) 13293 if !ok { 13294 return fmt.Errorf("unexpected JSON type %v", value) 13295 } 13296 13297 var sv *types.S3BucketOwner 13298 if *v == nil { 13299 sv = &types.S3BucketOwner{} 13300 } else { 13301 sv = *v 13302 } 13303 13304 for key, value := range shape { 13305 switch key { 13306 case "displayName": 13307 if value != nil { 13308 jtv, ok := value.(string) 13309 if !ok { 13310 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13311 } 13312 sv.DisplayName = ptr.String(jtv) 13313 } 13314 13315 case "id": 13316 if value != nil { 13317 jtv, ok := value.(string) 13318 if !ok { 13319 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13320 } 13321 sv.Id = ptr.String(jtv) 13322 } 13323 13324 default: 13325 _, _ = key, value 13326 13327 } 13328 } 13329 *v = sv 13330 return nil 13331} 13332 13333func awsRestjson1_deserializeDocumentS3Destination(v **types.S3Destination, value interface{}) error { 13334 if v == nil { 13335 return fmt.Errorf("unexpected nil of type %T", v) 13336 } 13337 if value == nil { 13338 return nil 13339 } 13340 13341 shape, ok := value.(map[string]interface{}) 13342 if !ok { 13343 return fmt.Errorf("unexpected JSON type %v", value) 13344 } 13345 13346 var sv *types.S3Destination 13347 if *v == nil { 13348 sv = &types.S3Destination{} 13349 } else { 13350 sv = *v 13351 } 13352 13353 for key, value := range shape { 13354 switch key { 13355 case "bucketName": 13356 if value != nil { 13357 jtv, ok := value.(string) 13358 if !ok { 13359 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13360 } 13361 sv.BucketName = ptr.String(jtv) 13362 } 13363 13364 case "keyPrefix": 13365 if value != nil { 13366 jtv, ok := value.(string) 13367 if !ok { 13368 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13369 } 13370 sv.KeyPrefix = ptr.String(jtv) 13371 } 13372 13373 case "kmsKeyArn": 13374 if value != nil { 13375 jtv, ok := value.(string) 13376 if !ok { 13377 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13378 } 13379 sv.KmsKeyArn = ptr.String(jtv) 13380 } 13381 13382 default: 13383 _, _ = key, value 13384 13385 } 13386 } 13387 *v = sv 13388 return nil 13389} 13390 13391func awsRestjson1_deserializeDocumentS3JobDefinition(v **types.S3JobDefinition, value interface{}) error { 13392 if v == nil { 13393 return fmt.Errorf("unexpected nil of type %T", v) 13394 } 13395 if value == nil { 13396 return nil 13397 } 13398 13399 shape, ok := value.(map[string]interface{}) 13400 if !ok { 13401 return fmt.Errorf("unexpected JSON type %v", value) 13402 } 13403 13404 var sv *types.S3JobDefinition 13405 if *v == nil { 13406 sv = &types.S3JobDefinition{} 13407 } else { 13408 sv = *v 13409 } 13410 13411 for key, value := range shape { 13412 switch key { 13413 case "bucketDefinitions": 13414 if err := awsRestjson1_deserializeDocument__listOfS3BucketDefinitionForJob(&sv.BucketDefinitions, value); err != nil { 13415 return err 13416 } 13417 13418 case "scoping": 13419 if err := awsRestjson1_deserializeDocumentScoping(&sv.Scoping, value); err != nil { 13420 return err 13421 } 13422 13423 default: 13424 _, _ = key, value 13425 13426 } 13427 } 13428 *v = sv 13429 return nil 13430} 13431 13432func awsRestjson1_deserializeDocumentS3Object(v **types.S3Object, value interface{}) error { 13433 if v == nil { 13434 return fmt.Errorf("unexpected nil of type %T", v) 13435 } 13436 if value == nil { 13437 return nil 13438 } 13439 13440 shape, ok := value.(map[string]interface{}) 13441 if !ok { 13442 return fmt.Errorf("unexpected JSON type %v", value) 13443 } 13444 13445 var sv *types.S3Object 13446 if *v == nil { 13447 sv = &types.S3Object{} 13448 } else { 13449 sv = *v 13450 } 13451 13452 for key, value := range shape { 13453 switch key { 13454 case "bucketArn": 13455 if value != nil { 13456 jtv, ok := value.(string) 13457 if !ok { 13458 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13459 } 13460 sv.BucketArn = ptr.String(jtv) 13461 } 13462 13463 case "eTag": 13464 if value != nil { 13465 jtv, ok := value.(string) 13466 if !ok { 13467 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13468 } 13469 sv.ETag = ptr.String(jtv) 13470 } 13471 13472 case "extension": 13473 if value != nil { 13474 jtv, ok := value.(string) 13475 if !ok { 13476 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13477 } 13478 sv.Extension = ptr.String(jtv) 13479 } 13480 13481 case "key": 13482 if value != nil { 13483 jtv, ok := value.(string) 13484 if !ok { 13485 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13486 } 13487 sv.Key = ptr.String(jtv) 13488 } 13489 13490 case "lastModified": 13491 if value != nil { 13492 jtv, ok := value.(string) 13493 if !ok { 13494 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 13495 } 13496 t, err := smithytime.ParseDateTime(jtv) 13497 if err != nil { 13498 return err 13499 } 13500 sv.LastModified = ptr.Time(t) 13501 } 13502 13503 case "path": 13504 if value != nil { 13505 jtv, ok := value.(string) 13506 if !ok { 13507 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13508 } 13509 sv.Path = ptr.String(jtv) 13510 } 13511 13512 case "publicAccess": 13513 if value != nil { 13514 jtv, ok := value.(bool) 13515 if !ok { 13516 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 13517 } 13518 sv.PublicAccess = jtv 13519 } 13520 13521 case "serverSideEncryption": 13522 if err := awsRestjson1_deserializeDocumentServerSideEncryption(&sv.ServerSideEncryption, value); err != nil { 13523 return err 13524 } 13525 13526 case "size": 13527 if value != nil { 13528 jtv, ok := value.(json.Number) 13529 if !ok { 13530 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13531 } 13532 i64, err := jtv.Int64() 13533 if err != nil { 13534 return err 13535 } 13536 sv.Size = i64 13537 } 13538 13539 case "storageClass": 13540 if value != nil { 13541 jtv, ok := value.(string) 13542 if !ok { 13543 return fmt.Errorf("expected StorageClass to be of type string, got %T instead", value) 13544 } 13545 sv.StorageClass = types.StorageClass(jtv) 13546 } 13547 13548 case "tags": 13549 if err := awsRestjson1_deserializeDocumentKeyValuePairList(&sv.Tags, value); err != nil { 13550 return err 13551 } 13552 13553 case "versionId": 13554 if value != nil { 13555 jtv, ok := value.(string) 13556 if !ok { 13557 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13558 } 13559 sv.VersionId = ptr.String(jtv) 13560 } 13561 13562 default: 13563 _, _ = key, value 13564 13565 } 13566 } 13567 *v = sv 13568 return nil 13569} 13570 13571func awsRestjson1_deserializeDocumentScoping(v **types.Scoping, value interface{}) error { 13572 if v == nil { 13573 return fmt.Errorf("unexpected nil of type %T", v) 13574 } 13575 if value == nil { 13576 return nil 13577 } 13578 13579 shape, ok := value.(map[string]interface{}) 13580 if !ok { 13581 return fmt.Errorf("unexpected JSON type %v", value) 13582 } 13583 13584 var sv *types.Scoping 13585 if *v == nil { 13586 sv = &types.Scoping{} 13587 } else { 13588 sv = *v 13589 } 13590 13591 for key, value := range shape { 13592 switch key { 13593 case "excludes": 13594 if err := awsRestjson1_deserializeDocumentJobScopingBlock(&sv.Excludes, value); err != nil { 13595 return err 13596 } 13597 13598 case "includes": 13599 if err := awsRestjson1_deserializeDocumentJobScopingBlock(&sv.Includes, value); err != nil { 13600 return err 13601 } 13602 13603 default: 13604 _, _ = key, value 13605 13606 } 13607 } 13608 *v = sv 13609 return nil 13610} 13611 13612func awsRestjson1_deserializeDocumentSensitiveData(v *[]types.SensitiveDataItem, value interface{}) error { 13613 if v == nil { 13614 return fmt.Errorf("unexpected nil of type %T", v) 13615 } 13616 if value == nil { 13617 return nil 13618 } 13619 13620 shape, ok := value.([]interface{}) 13621 if !ok { 13622 return fmt.Errorf("unexpected JSON type %v", value) 13623 } 13624 13625 var cv []types.SensitiveDataItem 13626 if *v == nil { 13627 cv = []types.SensitiveDataItem{} 13628 } else { 13629 cv = *v 13630 } 13631 13632 for _, value := range shape { 13633 var col types.SensitiveDataItem 13634 destAddr := &col 13635 if err := awsRestjson1_deserializeDocumentSensitiveDataItem(&destAddr, value); err != nil { 13636 return err 13637 } 13638 col = *destAddr 13639 cv = append(cv, col) 13640 13641 } 13642 *v = cv 13643 return nil 13644} 13645 13646func awsRestjson1_deserializeDocumentSensitiveDataItem(v **types.SensitiveDataItem, value interface{}) error { 13647 if v == nil { 13648 return fmt.Errorf("unexpected nil of type %T", v) 13649 } 13650 if value == nil { 13651 return nil 13652 } 13653 13654 shape, ok := value.(map[string]interface{}) 13655 if !ok { 13656 return fmt.Errorf("unexpected JSON type %v", value) 13657 } 13658 13659 var sv *types.SensitiveDataItem 13660 if *v == nil { 13661 sv = &types.SensitiveDataItem{} 13662 } else { 13663 sv = *v 13664 } 13665 13666 for key, value := range shape { 13667 switch key { 13668 case "category": 13669 if value != nil { 13670 jtv, ok := value.(string) 13671 if !ok { 13672 return fmt.Errorf("expected SensitiveDataItemCategory to be of type string, got %T instead", value) 13673 } 13674 sv.Category = types.SensitiveDataItemCategory(jtv) 13675 } 13676 13677 case "detections": 13678 if err := awsRestjson1_deserializeDocumentDefaultDetections(&sv.Detections, value); err != nil { 13679 return err 13680 } 13681 13682 case "totalCount": 13683 if value != nil { 13684 jtv, ok := value.(json.Number) 13685 if !ok { 13686 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13687 } 13688 i64, err := jtv.Int64() 13689 if err != nil { 13690 return err 13691 } 13692 sv.TotalCount = i64 13693 } 13694 13695 default: 13696 _, _ = key, value 13697 13698 } 13699 } 13700 *v = sv 13701 return nil 13702} 13703 13704func awsRestjson1_deserializeDocumentServerSideEncryption(v **types.ServerSideEncryption, value interface{}) error { 13705 if v == nil { 13706 return fmt.Errorf("unexpected nil of type %T", v) 13707 } 13708 if value == nil { 13709 return nil 13710 } 13711 13712 shape, ok := value.(map[string]interface{}) 13713 if !ok { 13714 return fmt.Errorf("unexpected JSON type %v", value) 13715 } 13716 13717 var sv *types.ServerSideEncryption 13718 if *v == nil { 13719 sv = &types.ServerSideEncryption{} 13720 } else { 13721 sv = *v 13722 } 13723 13724 for key, value := range shape { 13725 switch key { 13726 case "encryptionType": 13727 if value != nil { 13728 jtv, ok := value.(string) 13729 if !ok { 13730 return fmt.Errorf("expected EncryptionType to be of type string, got %T instead", value) 13731 } 13732 sv.EncryptionType = types.EncryptionType(jtv) 13733 } 13734 13735 case "kmsMasterKeyId": 13736 if value != nil { 13737 jtv, ok := value.(string) 13738 if !ok { 13739 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13740 } 13741 sv.KmsMasterKeyId = ptr.String(jtv) 13742 } 13743 13744 default: 13745 _, _ = key, value 13746 13747 } 13748 } 13749 *v = sv 13750 return nil 13751} 13752 13753func awsRestjson1_deserializeDocumentServiceLimit(v **types.ServiceLimit, value interface{}) error { 13754 if v == nil { 13755 return fmt.Errorf("unexpected nil of type %T", v) 13756 } 13757 if value == nil { 13758 return nil 13759 } 13760 13761 shape, ok := value.(map[string]interface{}) 13762 if !ok { 13763 return fmt.Errorf("unexpected JSON type %v", value) 13764 } 13765 13766 var sv *types.ServiceLimit 13767 if *v == nil { 13768 sv = &types.ServiceLimit{} 13769 } else { 13770 sv = *v 13771 } 13772 13773 for key, value := range shape { 13774 switch key { 13775 case "isServiceLimited": 13776 if value != nil { 13777 jtv, ok := value.(bool) 13778 if !ok { 13779 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 13780 } 13781 sv.IsServiceLimited = jtv 13782 } 13783 13784 case "unit": 13785 if value != nil { 13786 jtv, ok := value.(string) 13787 if !ok { 13788 return fmt.Errorf("expected Unit to be of type string, got %T instead", value) 13789 } 13790 sv.Unit = types.Unit(jtv) 13791 } 13792 13793 case "value": 13794 if value != nil { 13795 jtv, ok := value.(json.Number) 13796 if !ok { 13797 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13798 } 13799 i64, err := jtv.Int64() 13800 if err != nil { 13801 return err 13802 } 13803 sv.Value = i64 13804 } 13805 13806 default: 13807 _, _ = key, value 13808 13809 } 13810 } 13811 *v = sv 13812 return nil 13813} 13814 13815func awsRestjson1_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error { 13816 if v == nil { 13817 return fmt.Errorf("unexpected nil of type %T", v) 13818 } 13819 if value == nil { 13820 return nil 13821 } 13822 13823 shape, ok := value.(map[string]interface{}) 13824 if !ok { 13825 return fmt.Errorf("unexpected JSON type %v", value) 13826 } 13827 13828 var sv *types.ServiceQuotaExceededException 13829 if *v == nil { 13830 sv = &types.ServiceQuotaExceededException{} 13831 } else { 13832 sv = *v 13833 } 13834 13835 for key, value := range shape { 13836 switch key { 13837 case "message": 13838 if value != nil { 13839 jtv, ok := value.(string) 13840 if !ok { 13841 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13842 } 13843 sv.Message = ptr.String(jtv) 13844 } 13845 13846 default: 13847 _, _ = key, value 13848 13849 } 13850 } 13851 *v = sv 13852 return nil 13853} 13854 13855func awsRestjson1_deserializeDocumentSessionContext(v **types.SessionContext, value interface{}) error { 13856 if v == nil { 13857 return fmt.Errorf("unexpected nil of type %T", v) 13858 } 13859 if value == nil { 13860 return nil 13861 } 13862 13863 shape, ok := value.(map[string]interface{}) 13864 if !ok { 13865 return fmt.Errorf("unexpected JSON type %v", value) 13866 } 13867 13868 var sv *types.SessionContext 13869 if *v == nil { 13870 sv = &types.SessionContext{} 13871 } else { 13872 sv = *v 13873 } 13874 13875 for key, value := range shape { 13876 switch key { 13877 case "attributes": 13878 if err := awsRestjson1_deserializeDocumentSessionContextAttributes(&sv.Attributes, value); err != nil { 13879 return err 13880 } 13881 13882 case "sessionIssuer": 13883 if err := awsRestjson1_deserializeDocumentSessionIssuer(&sv.SessionIssuer, value); err != nil { 13884 return err 13885 } 13886 13887 default: 13888 _, _ = key, value 13889 13890 } 13891 } 13892 *v = sv 13893 return nil 13894} 13895 13896func awsRestjson1_deserializeDocumentSessionContextAttributes(v **types.SessionContextAttributes, value interface{}) error { 13897 if v == nil { 13898 return fmt.Errorf("unexpected nil of type %T", v) 13899 } 13900 if value == nil { 13901 return nil 13902 } 13903 13904 shape, ok := value.(map[string]interface{}) 13905 if !ok { 13906 return fmt.Errorf("unexpected JSON type %v", value) 13907 } 13908 13909 var sv *types.SessionContextAttributes 13910 if *v == nil { 13911 sv = &types.SessionContextAttributes{} 13912 } else { 13913 sv = *v 13914 } 13915 13916 for key, value := range shape { 13917 switch key { 13918 case "creationDate": 13919 if value != nil { 13920 jtv, ok := value.(string) 13921 if !ok { 13922 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 13923 } 13924 t, err := smithytime.ParseDateTime(jtv) 13925 if err != nil { 13926 return err 13927 } 13928 sv.CreationDate = ptr.Time(t) 13929 } 13930 13931 case "mfaAuthenticated": 13932 if value != nil { 13933 jtv, ok := value.(bool) 13934 if !ok { 13935 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 13936 } 13937 sv.MfaAuthenticated = jtv 13938 } 13939 13940 default: 13941 _, _ = key, value 13942 13943 } 13944 } 13945 *v = sv 13946 return nil 13947} 13948 13949func awsRestjson1_deserializeDocumentSessionIssuer(v **types.SessionIssuer, value interface{}) error { 13950 if v == nil { 13951 return fmt.Errorf("unexpected nil of type %T", v) 13952 } 13953 if value == nil { 13954 return nil 13955 } 13956 13957 shape, ok := value.(map[string]interface{}) 13958 if !ok { 13959 return fmt.Errorf("unexpected JSON type %v", value) 13960 } 13961 13962 var sv *types.SessionIssuer 13963 if *v == nil { 13964 sv = &types.SessionIssuer{} 13965 } else { 13966 sv = *v 13967 } 13968 13969 for key, value := range shape { 13970 switch key { 13971 case "accountId": 13972 if value != nil { 13973 jtv, ok := value.(string) 13974 if !ok { 13975 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13976 } 13977 sv.AccountId = ptr.String(jtv) 13978 } 13979 13980 case "arn": 13981 if value != nil { 13982 jtv, ok := value.(string) 13983 if !ok { 13984 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13985 } 13986 sv.Arn = ptr.String(jtv) 13987 } 13988 13989 case "principalId": 13990 if value != nil { 13991 jtv, ok := value.(string) 13992 if !ok { 13993 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13994 } 13995 sv.PrincipalId = ptr.String(jtv) 13996 } 13997 13998 case "type": 13999 if value != nil { 14000 jtv, ok := value.(string) 14001 if !ok { 14002 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14003 } 14004 sv.Type = ptr.String(jtv) 14005 } 14006 14007 case "userName": 14008 if value != nil { 14009 jtv, ok := value.(string) 14010 if !ok { 14011 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14012 } 14013 sv.UserName = ptr.String(jtv) 14014 } 14015 14016 default: 14017 _, _ = key, value 14018 14019 } 14020 } 14021 *v = sv 14022 return nil 14023} 14024 14025func awsRestjson1_deserializeDocumentSeverity(v **types.Severity, value interface{}) error { 14026 if v == nil { 14027 return fmt.Errorf("unexpected nil of type %T", v) 14028 } 14029 if value == nil { 14030 return nil 14031 } 14032 14033 shape, ok := value.(map[string]interface{}) 14034 if !ok { 14035 return fmt.Errorf("unexpected JSON type %v", value) 14036 } 14037 14038 var sv *types.Severity 14039 if *v == nil { 14040 sv = &types.Severity{} 14041 } else { 14042 sv = *v 14043 } 14044 14045 for key, value := range shape { 14046 switch key { 14047 case "description": 14048 if value != nil { 14049 jtv, ok := value.(string) 14050 if !ok { 14051 return fmt.Errorf("expected SeverityDescription to be of type string, got %T instead", value) 14052 } 14053 sv.Description = types.SeverityDescription(jtv) 14054 } 14055 14056 case "score": 14057 if value != nil { 14058 jtv, ok := value.(json.Number) 14059 if !ok { 14060 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 14061 } 14062 i64, err := jtv.Int64() 14063 if err != nil { 14064 return err 14065 } 14066 sv.Score = i64 14067 } 14068 14069 default: 14070 _, _ = key, value 14071 14072 } 14073 } 14074 *v = sv 14075 return nil 14076} 14077 14078func awsRestjson1_deserializeDocumentSimpleScopeTerm(v **types.SimpleScopeTerm, value interface{}) error { 14079 if v == nil { 14080 return fmt.Errorf("unexpected nil of type %T", v) 14081 } 14082 if value == nil { 14083 return nil 14084 } 14085 14086 shape, ok := value.(map[string]interface{}) 14087 if !ok { 14088 return fmt.Errorf("unexpected JSON type %v", value) 14089 } 14090 14091 var sv *types.SimpleScopeTerm 14092 if *v == nil { 14093 sv = &types.SimpleScopeTerm{} 14094 } else { 14095 sv = *v 14096 } 14097 14098 for key, value := range shape { 14099 switch key { 14100 case "comparator": 14101 if value != nil { 14102 jtv, ok := value.(string) 14103 if !ok { 14104 return fmt.Errorf("expected JobComparator to be of type string, got %T instead", value) 14105 } 14106 sv.Comparator = types.JobComparator(jtv) 14107 } 14108 14109 case "key": 14110 if value != nil { 14111 jtv, ok := value.(string) 14112 if !ok { 14113 return fmt.Errorf("expected ScopeFilterKey to be of type string, got %T instead", value) 14114 } 14115 sv.Key = types.ScopeFilterKey(jtv) 14116 } 14117 14118 case "values": 14119 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Values, value); err != nil { 14120 return err 14121 } 14122 14123 default: 14124 _, _ = key, value 14125 14126 } 14127 } 14128 *v = sv 14129 return nil 14130} 14131 14132func awsRestjson1_deserializeDocumentStatistics(v **types.Statistics, value interface{}) error { 14133 if v == nil { 14134 return fmt.Errorf("unexpected nil of type %T", v) 14135 } 14136 if value == nil { 14137 return nil 14138 } 14139 14140 shape, ok := value.(map[string]interface{}) 14141 if !ok { 14142 return fmt.Errorf("unexpected JSON type %v", value) 14143 } 14144 14145 var sv *types.Statistics 14146 if *v == nil { 14147 sv = &types.Statistics{} 14148 } else { 14149 sv = *v 14150 } 14151 14152 for key, value := range shape { 14153 switch key { 14154 case "approximateNumberOfObjectsToProcess": 14155 if value != nil { 14156 jtv, ok := value.(json.Number) 14157 if !ok { 14158 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 14159 } 14160 f64, err := jtv.Float64() 14161 if err != nil { 14162 return err 14163 } 14164 sv.ApproximateNumberOfObjectsToProcess = f64 14165 } 14166 14167 case "numberOfRuns": 14168 if value != nil { 14169 jtv, ok := value.(json.Number) 14170 if !ok { 14171 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 14172 } 14173 f64, err := jtv.Float64() 14174 if err != nil { 14175 return err 14176 } 14177 sv.NumberOfRuns = f64 14178 } 14179 14180 default: 14181 _, _ = key, value 14182 14183 } 14184 } 14185 *v = sv 14186 return nil 14187} 14188 14189func awsRestjson1_deserializeDocumentTagMap(v *map[string]string, value interface{}) error { 14190 if v == nil { 14191 return fmt.Errorf("unexpected nil of type %T", v) 14192 } 14193 if value == nil { 14194 return nil 14195 } 14196 14197 shape, ok := value.(map[string]interface{}) 14198 if !ok { 14199 return fmt.Errorf("unexpected JSON type %v", value) 14200 } 14201 14202 var mv map[string]string 14203 if *v == nil { 14204 mv = map[string]string{} 14205 } else { 14206 mv = *v 14207 } 14208 14209 for key, value := range shape { 14210 var parsedVal string 14211 if value != nil { 14212 jtv, ok := value.(string) 14213 if !ok { 14214 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14215 } 14216 parsedVal = jtv 14217 } 14218 mv[key] = parsedVal 14219 14220 } 14221 *v = mv 14222 return nil 14223} 14224 14225func awsRestjson1_deserializeDocumentTagScopeTerm(v **types.TagScopeTerm, value interface{}) error { 14226 if v == nil { 14227 return fmt.Errorf("unexpected nil of type %T", v) 14228 } 14229 if value == nil { 14230 return nil 14231 } 14232 14233 shape, ok := value.(map[string]interface{}) 14234 if !ok { 14235 return fmt.Errorf("unexpected JSON type %v", value) 14236 } 14237 14238 var sv *types.TagScopeTerm 14239 if *v == nil { 14240 sv = &types.TagScopeTerm{} 14241 } else { 14242 sv = *v 14243 } 14244 14245 for key, value := range shape { 14246 switch key { 14247 case "comparator": 14248 if value != nil { 14249 jtv, ok := value.(string) 14250 if !ok { 14251 return fmt.Errorf("expected JobComparator to be of type string, got %T instead", value) 14252 } 14253 sv.Comparator = types.JobComparator(jtv) 14254 } 14255 14256 case "key": 14257 if value != nil { 14258 jtv, ok := value.(string) 14259 if !ok { 14260 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14261 } 14262 sv.Key = ptr.String(jtv) 14263 } 14264 14265 case "tagValues": 14266 if err := awsRestjson1_deserializeDocument__listOfTagValuePair(&sv.TagValues, value); err != nil { 14267 return err 14268 } 14269 14270 case "target": 14271 if value != nil { 14272 jtv, ok := value.(string) 14273 if !ok { 14274 return fmt.Errorf("expected TagTarget to be of type string, got %T instead", value) 14275 } 14276 sv.Target = types.TagTarget(jtv) 14277 } 14278 14279 default: 14280 _, _ = key, value 14281 14282 } 14283 } 14284 *v = sv 14285 return nil 14286} 14287 14288func awsRestjson1_deserializeDocumentTagValuePair(v **types.TagValuePair, value interface{}) error { 14289 if v == nil { 14290 return fmt.Errorf("unexpected nil of type %T", v) 14291 } 14292 if value == nil { 14293 return nil 14294 } 14295 14296 shape, ok := value.(map[string]interface{}) 14297 if !ok { 14298 return fmt.Errorf("unexpected JSON type %v", value) 14299 } 14300 14301 var sv *types.TagValuePair 14302 if *v == nil { 14303 sv = &types.TagValuePair{} 14304 } else { 14305 sv = *v 14306 } 14307 14308 for key, value := range shape { 14309 switch key { 14310 case "key": 14311 if value != nil { 14312 jtv, ok := value.(string) 14313 if !ok { 14314 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14315 } 14316 sv.Key = ptr.String(jtv) 14317 } 14318 14319 case "value": 14320 if value != nil { 14321 jtv, ok := value.(string) 14322 if !ok { 14323 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14324 } 14325 sv.Value = ptr.String(jtv) 14326 } 14327 14328 default: 14329 _, _ = key, value 14330 14331 } 14332 } 14333 *v = sv 14334 return nil 14335} 14336 14337func awsRestjson1_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 14338 if v == nil { 14339 return fmt.Errorf("unexpected nil of type %T", v) 14340 } 14341 if value == nil { 14342 return nil 14343 } 14344 14345 shape, ok := value.(map[string]interface{}) 14346 if !ok { 14347 return fmt.Errorf("unexpected JSON type %v", value) 14348 } 14349 14350 var sv *types.ThrottlingException 14351 if *v == nil { 14352 sv = &types.ThrottlingException{} 14353 } else { 14354 sv = *v 14355 } 14356 14357 for key, value := range shape { 14358 switch key { 14359 case "message": 14360 if value != nil { 14361 jtv, ok := value.(string) 14362 if !ok { 14363 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14364 } 14365 sv.Message = ptr.String(jtv) 14366 } 14367 14368 default: 14369 _, _ = key, value 14370 14371 } 14372 } 14373 *v = sv 14374 return nil 14375} 14376 14377func awsRestjson1_deserializeDocumentUnprocessedAccount(v **types.UnprocessedAccount, value interface{}) error { 14378 if v == nil { 14379 return fmt.Errorf("unexpected nil of type %T", v) 14380 } 14381 if value == nil { 14382 return nil 14383 } 14384 14385 shape, ok := value.(map[string]interface{}) 14386 if !ok { 14387 return fmt.Errorf("unexpected JSON type %v", value) 14388 } 14389 14390 var sv *types.UnprocessedAccount 14391 if *v == nil { 14392 sv = &types.UnprocessedAccount{} 14393 } else { 14394 sv = *v 14395 } 14396 14397 for key, value := range shape { 14398 switch key { 14399 case "accountId": 14400 if value != nil { 14401 jtv, ok := value.(string) 14402 if !ok { 14403 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14404 } 14405 sv.AccountId = ptr.String(jtv) 14406 } 14407 14408 case "errorCode": 14409 if value != nil { 14410 jtv, ok := value.(string) 14411 if !ok { 14412 return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value) 14413 } 14414 sv.ErrorCode = types.ErrorCode(jtv) 14415 } 14416 14417 case "errorMessage": 14418 if value != nil { 14419 jtv, ok := value.(string) 14420 if !ok { 14421 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14422 } 14423 sv.ErrorMessage = ptr.String(jtv) 14424 } 14425 14426 default: 14427 _, _ = key, value 14428 14429 } 14430 } 14431 *v = sv 14432 return nil 14433} 14434 14435func awsRestjson1_deserializeDocumentUsageByAccount(v **types.UsageByAccount, value interface{}) error { 14436 if v == nil { 14437 return fmt.Errorf("unexpected nil of type %T", v) 14438 } 14439 if value == nil { 14440 return nil 14441 } 14442 14443 shape, ok := value.(map[string]interface{}) 14444 if !ok { 14445 return fmt.Errorf("unexpected JSON type %v", value) 14446 } 14447 14448 var sv *types.UsageByAccount 14449 if *v == nil { 14450 sv = &types.UsageByAccount{} 14451 } else { 14452 sv = *v 14453 } 14454 14455 for key, value := range shape { 14456 switch key { 14457 case "currency": 14458 if value != nil { 14459 jtv, ok := value.(string) 14460 if !ok { 14461 return fmt.Errorf("expected Currency to be of type string, got %T instead", value) 14462 } 14463 sv.Currency = types.Currency(jtv) 14464 } 14465 14466 case "estimatedCost": 14467 if value != nil { 14468 jtv, ok := value.(string) 14469 if !ok { 14470 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14471 } 14472 sv.EstimatedCost = ptr.String(jtv) 14473 } 14474 14475 case "serviceLimit": 14476 if err := awsRestjson1_deserializeDocumentServiceLimit(&sv.ServiceLimit, value); err != nil { 14477 return err 14478 } 14479 14480 case "type": 14481 if value != nil { 14482 jtv, ok := value.(string) 14483 if !ok { 14484 return fmt.Errorf("expected UsageType to be of type string, got %T instead", value) 14485 } 14486 sv.Type = types.UsageType(jtv) 14487 } 14488 14489 default: 14490 _, _ = key, value 14491 14492 } 14493 } 14494 *v = sv 14495 return nil 14496} 14497 14498func awsRestjson1_deserializeDocumentUsageRecord(v **types.UsageRecord, value interface{}) error { 14499 if v == nil { 14500 return fmt.Errorf("unexpected nil of type %T", v) 14501 } 14502 if value == nil { 14503 return nil 14504 } 14505 14506 shape, ok := value.(map[string]interface{}) 14507 if !ok { 14508 return fmt.Errorf("unexpected JSON type %v", value) 14509 } 14510 14511 var sv *types.UsageRecord 14512 if *v == nil { 14513 sv = &types.UsageRecord{} 14514 } else { 14515 sv = *v 14516 } 14517 14518 for key, value := range shape { 14519 switch key { 14520 case "accountId": 14521 if value != nil { 14522 jtv, ok := value.(string) 14523 if !ok { 14524 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14525 } 14526 sv.AccountId = ptr.String(jtv) 14527 } 14528 14529 case "freeTrialStartDate": 14530 if value != nil { 14531 jtv, ok := value.(string) 14532 if !ok { 14533 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 14534 } 14535 t, err := smithytime.ParseDateTime(jtv) 14536 if err != nil { 14537 return err 14538 } 14539 sv.FreeTrialStartDate = ptr.Time(t) 14540 } 14541 14542 case "usage": 14543 if err := awsRestjson1_deserializeDocument__listOfUsageByAccount(&sv.Usage, value); err != nil { 14544 return err 14545 } 14546 14547 default: 14548 _, _ = key, value 14549 14550 } 14551 } 14552 *v = sv 14553 return nil 14554} 14555 14556func awsRestjson1_deserializeDocumentUsageTotal(v **types.UsageTotal, value interface{}) error { 14557 if v == nil { 14558 return fmt.Errorf("unexpected nil of type %T", v) 14559 } 14560 if value == nil { 14561 return nil 14562 } 14563 14564 shape, ok := value.(map[string]interface{}) 14565 if !ok { 14566 return fmt.Errorf("unexpected JSON type %v", value) 14567 } 14568 14569 var sv *types.UsageTotal 14570 if *v == nil { 14571 sv = &types.UsageTotal{} 14572 } else { 14573 sv = *v 14574 } 14575 14576 for key, value := range shape { 14577 switch key { 14578 case "currency": 14579 if value != nil { 14580 jtv, ok := value.(string) 14581 if !ok { 14582 return fmt.Errorf("expected Currency to be of type string, got %T instead", value) 14583 } 14584 sv.Currency = types.Currency(jtv) 14585 } 14586 14587 case "estimatedCost": 14588 if value != nil { 14589 jtv, ok := value.(string) 14590 if !ok { 14591 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14592 } 14593 sv.EstimatedCost = ptr.String(jtv) 14594 } 14595 14596 case "type": 14597 if value != nil { 14598 jtv, ok := value.(string) 14599 if !ok { 14600 return fmt.Errorf("expected UsageType to be of type string, got %T instead", value) 14601 } 14602 sv.Type = types.UsageType(jtv) 14603 } 14604 14605 default: 14606 _, _ = key, value 14607 14608 } 14609 } 14610 *v = sv 14611 return nil 14612} 14613 14614func awsRestjson1_deserializeDocumentUserIdentity(v **types.UserIdentity, value interface{}) error { 14615 if v == nil { 14616 return fmt.Errorf("unexpected nil of type %T", v) 14617 } 14618 if value == nil { 14619 return nil 14620 } 14621 14622 shape, ok := value.(map[string]interface{}) 14623 if !ok { 14624 return fmt.Errorf("unexpected JSON type %v", value) 14625 } 14626 14627 var sv *types.UserIdentity 14628 if *v == nil { 14629 sv = &types.UserIdentity{} 14630 } else { 14631 sv = *v 14632 } 14633 14634 for key, value := range shape { 14635 switch key { 14636 case "assumedRole": 14637 if err := awsRestjson1_deserializeDocumentAssumedRole(&sv.AssumedRole, value); err != nil { 14638 return err 14639 } 14640 14641 case "awsAccount": 14642 if err := awsRestjson1_deserializeDocumentAwsAccount(&sv.AwsAccount, value); err != nil { 14643 return err 14644 } 14645 14646 case "awsService": 14647 if err := awsRestjson1_deserializeDocumentAwsService(&sv.AwsService, value); err != nil { 14648 return err 14649 } 14650 14651 case "federatedUser": 14652 if err := awsRestjson1_deserializeDocumentFederatedUser(&sv.FederatedUser, value); err != nil { 14653 return err 14654 } 14655 14656 case "iamUser": 14657 if err := awsRestjson1_deserializeDocumentIamUser(&sv.IamUser, value); err != nil { 14658 return err 14659 } 14660 14661 case "root": 14662 if err := awsRestjson1_deserializeDocumentUserIdentityRoot(&sv.Root, value); err != nil { 14663 return err 14664 } 14665 14666 case "type": 14667 if value != nil { 14668 jtv, ok := value.(string) 14669 if !ok { 14670 return fmt.Errorf("expected UserIdentityType to be of type string, got %T instead", value) 14671 } 14672 sv.Type = types.UserIdentityType(jtv) 14673 } 14674 14675 default: 14676 _, _ = key, value 14677 14678 } 14679 } 14680 *v = sv 14681 return nil 14682} 14683 14684func awsRestjson1_deserializeDocumentUserIdentityRoot(v **types.UserIdentityRoot, value interface{}) error { 14685 if v == nil { 14686 return fmt.Errorf("unexpected nil of type %T", v) 14687 } 14688 if value == nil { 14689 return nil 14690 } 14691 14692 shape, ok := value.(map[string]interface{}) 14693 if !ok { 14694 return fmt.Errorf("unexpected JSON type %v", value) 14695 } 14696 14697 var sv *types.UserIdentityRoot 14698 if *v == nil { 14699 sv = &types.UserIdentityRoot{} 14700 } else { 14701 sv = *v 14702 } 14703 14704 for key, value := range shape { 14705 switch key { 14706 case "accountId": 14707 if value != nil { 14708 jtv, ok := value.(string) 14709 if !ok { 14710 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14711 } 14712 sv.AccountId = ptr.String(jtv) 14713 } 14714 14715 case "arn": 14716 if value != nil { 14717 jtv, ok := value.(string) 14718 if !ok { 14719 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14720 } 14721 sv.Arn = ptr.String(jtv) 14722 } 14723 14724 case "principalId": 14725 if value != nil { 14726 jtv, ok := value.(string) 14727 if !ok { 14728 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14729 } 14730 sv.PrincipalId = ptr.String(jtv) 14731 } 14732 14733 default: 14734 _, _ = key, value 14735 14736 } 14737 } 14738 *v = sv 14739 return nil 14740} 14741 14742func awsRestjson1_deserializeDocumentUserPausedDetails(v **types.UserPausedDetails, value interface{}) error { 14743 if v == nil { 14744 return fmt.Errorf("unexpected nil of type %T", v) 14745 } 14746 if value == nil { 14747 return nil 14748 } 14749 14750 shape, ok := value.(map[string]interface{}) 14751 if !ok { 14752 return fmt.Errorf("unexpected JSON type %v", value) 14753 } 14754 14755 var sv *types.UserPausedDetails 14756 if *v == nil { 14757 sv = &types.UserPausedDetails{} 14758 } else { 14759 sv = *v 14760 } 14761 14762 for key, value := range shape { 14763 switch key { 14764 case "jobExpiresAt": 14765 if value != nil { 14766 jtv, ok := value.(string) 14767 if !ok { 14768 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 14769 } 14770 t, err := smithytime.ParseDateTime(jtv) 14771 if err != nil { 14772 return err 14773 } 14774 sv.JobExpiresAt = ptr.Time(t) 14775 } 14776 14777 case "jobImminentExpirationHealthEventArn": 14778 if value != nil { 14779 jtv, ok := value.(string) 14780 if !ok { 14781 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14782 } 14783 sv.JobImminentExpirationHealthEventArn = ptr.String(jtv) 14784 } 14785 14786 case "jobPausedAt": 14787 if value != nil { 14788 jtv, ok := value.(string) 14789 if !ok { 14790 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 14791 } 14792 t, err := smithytime.ParseDateTime(jtv) 14793 if err != nil { 14794 return err 14795 } 14796 sv.JobPausedAt = ptr.Time(t) 14797 } 14798 14799 default: 14800 _, _ = key, value 14801 14802 } 14803 } 14804 *v = sv 14805 return nil 14806} 14807 14808func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 14809 if v == nil { 14810 return fmt.Errorf("unexpected nil of type %T", v) 14811 } 14812 if value == nil { 14813 return nil 14814 } 14815 14816 shape, ok := value.(map[string]interface{}) 14817 if !ok { 14818 return fmt.Errorf("unexpected JSON type %v", value) 14819 } 14820 14821 var sv *types.ValidationException 14822 if *v == nil { 14823 sv = &types.ValidationException{} 14824 } else { 14825 sv = *v 14826 } 14827 14828 for key, value := range shape { 14829 switch key { 14830 case "message": 14831 if value != nil { 14832 jtv, ok := value.(string) 14833 if !ok { 14834 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14835 } 14836 sv.Message = ptr.String(jtv) 14837 } 14838 14839 default: 14840 _, _ = key, value 14841 14842 } 14843 } 14844 *v = sv 14845 return nil 14846} 14847 14848func awsRestjson1_deserializeDocumentWeeklySchedule(v **types.WeeklySchedule, value interface{}) error { 14849 if v == nil { 14850 return fmt.Errorf("unexpected nil of type %T", v) 14851 } 14852 if value == nil { 14853 return nil 14854 } 14855 14856 shape, ok := value.(map[string]interface{}) 14857 if !ok { 14858 return fmt.Errorf("unexpected JSON type %v", value) 14859 } 14860 14861 var sv *types.WeeklySchedule 14862 if *v == nil { 14863 sv = &types.WeeklySchedule{} 14864 } else { 14865 sv = *v 14866 } 14867 14868 for key, value := range shape { 14869 switch key { 14870 case "dayOfWeek": 14871 if value != nil { 14872 jtv, ok := value.(string) 14873 if !ok { 14874 return fmt.Errorf("expected DayOfWeek to be of type string, got %T instead", value) 14875 } 14876 sv.DayOfWeek = types.DayOfWeek(jtv) 14877 } 14878 14879 default: 14880 _, _ = key, value 14881 14882 } 14883 } 14884 *v = sv 14885 return nil 14886} 14887