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_deserializeOpDisassociateFromAdministratorAccount struct { 2747} 2748 2749func (*awsRestjson1_deserializeOpDisassociateFromAdministratorAccount) ID() string { 2750 return "OperationDeserializer" 2751} 2752 2753func (m *awsRestjson1_deserializeOpDisassociateFromAdministratorAccount) 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_deserializeOpErrorDisassociateFromAdministratorAccount(response, &metadata) 2768 } 2769 output := &DisassociateFromAdministratorAccountOutput{} 2770 out.Result = output 2771 2772 return out, metadata, err 2773} 2774 2775func awsRestjson1_deserializeOpErrorDisassociateFromAdministratorAccount(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_deserializeOpDisassociateFromMasterAccount struct { 2848} 2849 2850func (*awsRestjson1_deserializeOpDisassociateFromMasterAccount) ID() string { 2851 return "OperationDeserializer" 2852} 2853 2854func (m *awsRestjson1_deserializeOpDisassociateFromMasterAccount) 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_deserializeOpErrorDisassociateFromMasterAccount(response, &metadata) 2869 } 2870 output := &DisassociateFromMasterAccountOutput{} 2871 out.Result = output 2872 2873 return out, metadata, err 2874} 2875 2876func awsRestjson1_deserializeOpErrorDisassociateFromMasterAccount(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_deserializeOpDisassociateMember struct { 2949} 2950 2951func (*awsRestjson1_deserializeOpDisassociateMember) ID() string { 2952 return "OperationDeserializer" 2953} 2954 2955func (m *awsRestjson1_deserializeOpDisassociateMember) 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_deserializeOpErrorDisassociateMember(response, &metadata) 2970 } 2971 output := &DisassociateMemberOutput{} 2972 out.Result = output 2973 2974 return out, metadata, err 2975} 2976 2977func awsRestjson1_deserializeOpErrorDisassociateMember(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_deserializeOpEnableMacie struct { 3050} 3051 3052func (*awsRestjson1_deserializeOpEnableMacie) ID() string { 3053 return "OperationDeserializer" 3054} 3055 3056func (m *awsRestjson1_deserializeOpEnableMacie) 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_deserializeOpErrorEnableMacie(response, &metadata) 3071 } 3072 output := &EnableMacieOutput{} 3073 out.Result = output 3074 3075 return out, metadata, err 3076} 3077 3078func awsRestjson1_deserializeOpErrorEnableMacie(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_deserializeOpEnableOrganizationAdminAccount struct { 3151} 3152 3153func (*awsRestjson1_deserializeOpEnableOrganizationAdminAccount) ID() string { 3154 return "OperationDeserializer" 3155} 3156 3157func (m *awsRestjson1_deserializeOpEnableOrganizationAdminAccount) 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_deserializeOpErrorEnableOrganizationAdminAccount(response, &metadata) 3172 } 3173 output := &EnableOrganizationAdminAccountOutput{} 3174 out.Result = output 3175 3176 return out, metadata, err 3177} 3178 3179func awsRestjson1_deserializeOpErrorEnableOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3180 var errorBuffer bytes.Buffer 3181 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3182 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3183 } 3184 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3185 3186 errorCode := "UnknownError" 3187 errorMessage := errorCode 3188 3189 code := response.Header.Get("X-Amzn-ErrorType") 3190 if len(code) != 0 { 3191 errorCode = restjson.SanitizeErrorCode(code) 3192 } 3193 3194 var buff [1024]byte 3195 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3196 3197 body := io.TeeReader(errorBody, ringBuffer) 3198 decoder := json.NewDecoder(body) 3199 decoder.UseNumber() 3200 code, message, err := restjson.GetErrorInfo(decoder) 3201 if err != nil { 3202 var snapshot bytes.Buffer 3203 io.Copy(&snapshot, ringBuffer) 3204 err = &smithy.DeserializationError{ 3205 Err: fmt.Errorf("failed to decode response body, %w", err), 3206 Snapshot: snapshot.Bytes(), 3207 } 3208 return err 3209 } 3210 3211 errorBody.Seek(0, io.SeekStart) 3212 if len(code) != 0 { 3213 errorCode = restjson.SanitizeErrorCode(code) 3214 } 3215 if len(message) != 0 { 3216 errorMessage = message 3217 } 3218 3219 switch { 3220 case strings.EqualFold("AccessDeniedException", errorCode): 3221 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3222 3223 case strings.EqualFold("ConflictException", errorCode): 3224 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3225 3226 case strings.EqualFold("InternalServerException", errorCode): 3227 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3228 3229 case strings.EqualFold("ResourceNotFoundException", errorCode): 3230 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3231 3232 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3233 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3234 3235 case strings.EqualFold("ThrottlingException", errorCode): 3236 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3237 3238 case strings.EqualFold("ValidationException", errorCode): 3239 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3240 3241 default: 3242 genericError := &smithy.GenericAPIError{ 3243 Code: errorCode, 3244 Message: errorMessage, 3245 } 3246 return genericError 3247 3248 } 3249} 3250 3251type awsRestjson1_deserializeOpGetAdministratorAccount struct { 3252} 3253 3254func (*awsRestjson1_deserializeOpGetAdministratorAccount) ID() string { 3255 return "OperationDeserializer" 3256} 3257 3258func (m *awsRestjson1_deserializeOpGetAdministratorAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3259 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3260) { 3261 out, metadata, err = next.HandleDeserialize(ctx, in) 3262 if err != nil { 3263 return out, metadata, err 3264 } 3265 3266 response, ok := out.RawResponse.(*smithyhttp.Response) 3267 if !ok { 3268 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3269 } 3270 3271 if response.StatusCode < 200 || response.StatusCode >= 300 { 3272 return out, metadata, awsRestjson1_deserializeOpErrorGetAdministratorAccount(response, &metadata) 3273 } 3274 output := &GetAdministratorAccountOutput{} 3275 out.Result = output 3276 3277 var buff [1024]byte 3278 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3279 3280 body := io.TeeReader(response.Body, ringBuffer) 3281 3282 decoder := json.NewDecoder(body) 3283 decoder.UseNumber() 3284 var shape interface{} 3285 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3286 var snapshot bytes.Buffer 3287 io.Copy(&snapshot, ringBuffer) 3288 err = &smithy.DeserializationError{ 3289 Err: fmt.Errorf("failed to decode response body, %w", err), 3290 Snapshot: snapshot.Bytes(), 3291 } 3292 return out, metadata, err 3293 } 3294 3295 err = awsRestjson1_deserializeOpDocumentGetAdministratorAccountOutput(&output, shape) 3296 if err != nil { 3297 var snapshot bytes.Buffer 3298 io.Copy(&snapshot, ringBuffer) 3299 return out, metadata, &smithy.DeserializationError{ 3300 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3301 Snapshot: snapshot.Bytes(), 3302 } 3303 } 3304 3305 return out, metadata, err 3306} 3307 3308func awsRestjson1_deserializeOpErrorGetAdministratorAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3309 var errorBuffer bytes.Buffer 3310 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3311 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3312 } 3313 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3314 3315 errorCode := "UnknownError" 3316 errorMessage := errorCode 3317 3318 code := response.Header.Get("X-Amzn-ErrorType") 3319 if len(code) != 0 { 3320 errorCode = restjson.SanitizeErrorCode(code) 3321 } 3322 3323 var buff [1024]byte 3324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3325 3326 body := io.TeeReader(errorBody, ringBuffer) 3327 decoder := json.NewDecoder(body) 3328 decoder.UseNumber() 3329 code, message, err := restjson.GetErrorInfo(decoder) 3330 if err != nil { 3331 var snapshot bytes.Buffer 3332 io.Copy(&snapshot, ringBuffer) 3333 err = &smithy.DeserializationError{ 3334 Err: fmt.Errorf("failed to decode response body, %w", err), 3335 Snapshot: snapshot.Bytes(), 3336 } 3337 return err 3338 } 3339 3340 errorBody.Seek(0, io.SeekStart) 3341 if len(code) != 0 { 3342 errorCode = restjson.SanitizeErrorCode(code) 3343 } 3344 if len(message) != 0 { 3345 errorMessage = message 3346 } 3347 3348 switch { 3349 case strings.EqualFold("AccessDeniedException", errorCode): 3350 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3351 3352 case strings.EqualFold("ConflictException", errorCode): 3353 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3354 3355 case strings.EqualFold("InternalServerException", errorCode): 3356 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3357 3358 case strings.EqualFold("ResourceNotFoundException", errorCode): 3359 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3360 3361 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3362 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3363 3364 case strings.EqualFold("ThrottlingException", errorCode): 3365 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3366 3367 case strings.EqualFold("ValidationException", errorCode): 3368 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3369 3370 default: 3371 genericError := &smithy.GenericAPIError{ 3372 Code: errorCode, 3373 Message: errorMessage, 3374 } 3375 return genericError 3376 3377 } 3378} 3379 3380func awsRestjson1_deserializeOpDocumentGetAdministratorAccountOutput(v **GetAdministratorAccountOutput, value interface{}) error { 3381 if v == nil { 3382 return fmt.Errorf("unexpected nil of type %T", v) 3383 } 3384 if value == nil { 3385 return nil 3386 } 3387 3388 shape, ok := value.(map[string]interface{}) 3389 if !ok { 3390 return fmt.Errorf("unexpected JSON type %v", value) 3391 } 3392 3393 var sv *GetAdministratorAccountOutput 3394 if *v == nil { 3395 sv = &GetAdministratorAccountOutput{} 3396 } else { 3397 sv = *v 3398 } 3399 3400 for key, value := range shape { 3401 switch key { 3402 case "administrator": 3403 if err := awsRestjson1_deserializeDocumentInvitation(&sv.Administrator, value); err != nil { 3404 return err 3405 } 3406 3407 default: 3408 _, _ = key, value 3409 3410 } 3411 } 3412 *v = sv 3413 return nil 3414} 3415 3416type awsRestjson1_deserializeOpGetBucketStatistics struct { 3417} 3418 3419func (*awsRestjson1_deserializeOpGetBucketStatistics) ID() string { 3420 return "OperationDeserializer" 3421} 3422 3423func (m *awsRestjson1_deserializeOpGetBucketStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3424 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3425) { 3426 out, metadata, err = next.HandleDeserialize(ctx, in) 3427 if err != nil { 3428 return out, metadata, err 3429 } 3430 3431 response, ok := out.RawResponse.(*smithyhttp.Response) 3432 if !ok { 3433 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3434 } 3435 3436 if response.StatusCode < 200 || response.StatusCode >= 300 { 3437 return out, metadata, awsRestjson1_deserializeOpErrorGetBucketStatistics(response, &metadata) 3438 } 3439 output := &GetBucketStatisticsOutput{} 3440 out.Result = output 3441 3442 var buff [1024]byte 3443 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3444 3445 body := io.TeeReader(response.Body, ringBuffer) 3446 3447 decoder := json.NewDecoder(body) 3448 decoder.UseNumber() 3449 var shape interface{} 3450 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3451 var snapshot bytes.Buffer 3452 io.Copy(&snapshot, ringBuffer) 3453 err = &smithy.DeserializationError{ 3454 Err: fmt.Errorf("failed to decode response body, %w", err), 3455 Snapshot: snapshot.Bytes(), 3456 } 3457 return out, metadata, err 3458 } 3459 3460 err = awsRestjson1_deserializeOpDocumentGetBucketStatisticsOutput(&output, shape) 3461 if err != nil { 3462 var snapshot bytes.Buffer 3463 io.Copy(&snapshot, ringBuffer) 3464 return out, metadata, &smithy.DeserializationError{ 3465 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3466 Snapshot: snapshot.Bytes(), 3467 } 3468 } 3469 3470 return out, metadata, err 3471} 3472 3473func awsRestjson1_deserializeOpErrorGetBucketStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3474 var errorBuffer bytes.Buffer 3475 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3476 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3477 } 3478 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3479 3480 errorCode := "UnknownError" 3481 errorMessage := errorCode 3482 3483 code := response.Header.Get("X-Amzn-ErrorType") 3484 if len(code) != 0 { 3485 errorCode = restjson.SanitizeErrorCode(code) 3486 } 3487 3488 var buff [1024]byte 3489 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3490 3491 body := io.TeeReader(errorBody, ringBuffer) 3492 decoder := json.NewDecoder(body) 3493 decoder.UseNumber() 3494 code, message, err := restjson.GetErrorInfo(decoder) 3495 if err != nil { 3496 var snapshot bytes.Buffer 3497 io.Copy(&snapshot, ringBuffer) 3498 err = &smithy.DeserializationError{ 3499 Err: fmt.Errorf("failed to decode response body, %w", err), 3500 Snapshot: snapshot.Bytes(), 3501 } 3502 return err 3503 } 3504 3505 errorBody.Seek(0, io.SeekStart) 3506 if len(code) != 0 { 3507 errorCode = restjson.SanitizeErrorCode(code) 3508 } 3509 if len(message) != 0 { 3510 errorMessage = message 3511 } 3512 3513 switch { 3514 case strings.EqualFold("AccessDeniedException", errorCode): 3515 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3516 3517 case strings.EqualFold("ConflictException", errorCode): 3518 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3519 3520 case strings.EqualFold("InternalServerException", errorCode): 3521 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3522 3523 case strings.EqualFold("ResourceNotFoundException", errorCode): 3524 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3525 3526 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3527 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3528 3529 case strings.EqualFold("ThrottlingException", errorCode): 3530 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3531 3532 case strings.EqualFold("ValidationException", errorCode): 3533 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3534 3535 default: 3536 genericError := &smithy.GenericAPIError{ 3537 Code: errorCode, 3538 Message: errorMessage, 3539 } 3540 return genericError 3541 3542 } 3543} 3544 3545func awsRestjson1_deserializeOpDocumentGetBucketStatisticsOutput(v **GetBucketStatisticsOutput, value interface{}) error { 3546 if v == nil { 3547 return fmt.Errorf("unexpected nil of type %T", v) 3548 } 3549 if value == nil { 3550 return nil 3551 } 3552 3553 shape, ok := value.(map[string]interface{}) 3554 if !ok { 3555 return fmt.Errorf("unexpected JSON type %v", value) 3556 } 3557 3558 var sv *GetBucketStatisticsOutput 3559 if *v == nil { 3560 sv = &GetBucketStatisticsOutput{} 3561 } else { 3562 sv = *v 3563 } 3564 3565 for key, value := range shape { 3566 switch key { 3567 case "bucketCount": 3568 if value != nil { 3569 jtv, ok := value.(json.Number) 3570 if !ok { 3571 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3572 } 3573 i64, err := jtv.Int64() 3574 if err != nil { 3575 return err 3576 } 3577 sv.BucketCount = i64 3578 } 3579 3580 case "bucketCountByEffectivePermission": 3581 if err := awsRestjson1_deserializeDocumentBucketCountByEffectivePermission(&sv.BucketCountByEffectivePermission, value); err != nil { 3582 return err 3583 } 3584 3585 case "bucketCountByEncryptionType": 3586 if err := awsRestjson1_deserializeDocumentBucketCountByEncryptionType(&sv.BucketCountByEncryptionType, value); err != nil { 3587 return err 3588 } 3589 3590 case "bucketCountByObjectEncryptionRequirement": 3591 if err := awsRestjson1_deserializeDocumentBucketCountPolicyAllowsUnencryptedObjectUploads(&sv.BucketCountByObjectEncryptionRequirement, value); err != nil { 3592 return err 3593 } 3594 3595 case "bucketCountBySharedAccessType": 3596 if err := awsRestjson1_deserializeDocumentBucketCountBySharedAccessType(&sv.BucketCountBySharedAccessType, value); err != nil { 3597 return err 3598 } 3599 3600 case "classifiableObjectCount": 3601 if value != nil { 3602 jtv, ok := value.(json.Number) 3603 if !ok { 3604 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3605 } 3606 i64, err := jtv.Int64() 3607 if err != nil { 3608 return err 3609 } 3610 sv.ClassifiableObjectCount = i64 3611 } 3612 3613 case "classifiableSizeInBytes": 3614 if value != nil { 3615 jtv, ok := value.(json.Number) 3616 if !ok { 3617 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3618 } 3619 i64, err := jtv.Int64() 3620 if err != nil { 3621 return err 3622 } 3623 sv.ClassifiableSizeInBytes = i64 3624 } 3625 3626 case "lastUpdated": 3627 if value != nil { 3628 jtv, ok := value.(string) 3629 if !ok { 3630 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 3631 } 3632 t, err := smithytime.ParseDateTime(jtv) 3633 if err != nil { 3634 return err 3635 } 3636 sv.LastUpdated = ptr.Time(t) 3637 } 3638 3639 case "objectCount": 3640 if value != nil { 3641 jtv, ok := value.(json.Number) 3642 if !ok { 3643 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3644 } 3645 i64, err := jtv.Int64() 3646 if err != nil { 3647 return err 3648 } 3649 sv.ObjectCount = i64 3650 } 3651 3652 case "sizeInBytes": 3653 if value != nil { 3654 jtv, ok := value.(json.Number) 3655 if !ok { 3656 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3657 } 3658 i64, err := jtv.Int64() 3659 if err != nil { 3660 return err 3661 } 3662 sv.SizeInBytes = i64 3663 } 3664 3665 case "sizeInBytesCompressed": 3666 if value != nil { 3667 jtv, ok := value.(json.Number) 3668 if !ok { 3669 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 3670 } 3671 i64, err := jtv.Int64() 3672 if err != nil { 3673 return err 3674 } 3675 sv.SizeInBytesCompressed = i64 3676 } 3677 3678 case "unclassifiableObjectCount": 3679 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectCount, value); err != nil { 3680 return err 3681 } 3682 3683 case "unclassifiableObjectSizeInBytes": 3684 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectSizeInBytes, value); err != nil { 3685 return err 3686 } 3687 3688 default: 3689 _, _ = key, value 3690 3691 } 3692 } 3693 *v = sv 3694 return nil 3695} 3696 3697type awsRestjson1_deserializeOpGetClassificationExportConfiguration struct { 3698} 3699 3700func (*awsRestjson1_deserializeOpGetClassificationExportConfiguration) ID() string { 3701 return "OperationDeserializer" 3702} 3703 3704func (m *awsRestjson1_deserializeOpGetClassificationExportConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3705 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3706) { 3707 out, metadata, err = next.HandleDeserialize(ctx, in) 3708 if err != nil { 3709 return out, metadata, err 3710 } 3711 3712 response, ok := out.RawResponse.(*smithyhttp.Response) 3713 if !ok { 3714 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3715 } 3716 3717 if response.StatusCode < 200 || response.StatusCode >= 300 { 3718 return out, metadata, awsRestjson1_deserializeOpErrorGetClassificationExportConfiguration(response, &metadata) 3719 } 3720 output := &GetClassificationExportConfigurationOutput{} 3721 out.Result = output 3722 3723 var buff [1024]byte 3724 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3725 3726 body := io.TeeReader(response.Body, ringBuffer) 3727 3728 decoder := json.NewDecoder(body) 3729 decoder.UseNumber() 3730 var shape interface{} 3731 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3732 var snapshot bytes.Buffer 3733 io.Copy(&snapshot, ringBuffer) 3734 err = &smithy.DeserializationError{ 3735 Err: fmt.Errorf("failed to decode response body, %w", err), 3736 Snapshot: snapshot.Bytes(), 3737 } 3738 return out, metadata, err 3739 } 3740 3741 err = awsRestjson1_deserializeOpDocumentGetClassificationExportConfigurationOutput(&output, shape) 3742 if err != nil { 3743 var snapshot bytes.Buffer 3744 io.Copy(&snapshot, ringBuffer) 3745 return out, metadata, &smithy.DeserializationError{ 3746 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3747 Snapshot: snapshot.Bytes(), 3748 } 3749 } 3750 3751 return out, metadata, err 3752} 3753 3754func awsRestjson1_deserializeOpErrorGetClassificationExportConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3755 var errorBuffer bytes.Buffer 3756 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3757 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3758 } 3759 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3760 3761 errorCode := "UnknownError" 3762 errorMessage := errorCode 3763 3764 code := response.Header.Get("X-Amzn-ErrorType") 3765 if len(code) != 0 { 3766 errorCode = restjson.SanitizeErrorCode(code) 3767 } 3768 3769 var buff [1024]byte 3770 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3771 3772 body := io.TeeReader(errorBody, ringBuffer) 3773 decoder := json.NewDecoder(body) 3774 decoder.UseNumber() 3775 code, message, err := restjson.GetErrorInfo(decoder) 3776 if err != nil { 3777 var snapshot bytes.Buffer 3778 io.Copy(&snapshot, ringBuffer) 3779 err = &smithy.DeserializationError{ 3780 Err: fmt.Errorf("failed to decode response body, %w", err), 3781 Snapshot: snapshot.Bytes(), 3782 } 3783 return err 3784 } 3785 3786 errorBody.Seek(0, io.SeekStart) 3787 if len(code) != 0 { 3788 errorCode = restjson.SanitizeErrorCode(code) 3789 } 3790 if len(message) != 0 { 3791 errorMessage = message 3792 } 3793 3794 switch { 3795 case strings.EqualFold("AccessDeniedException", errorCode): 3796 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3797 3798 case strings.EqualFold("ConflictException", errorCode): 3799 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3800 3801 case strings.EqualFold("InternalServerException", errorCode): 3802 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3803 3804 case strings.EqualFold("ResourceNotFoundException", errorCode): 3805 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3806 3807 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3808 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3809 3810 case strings.EqualFold("ThrottlingException", errorCode): 3811 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3812 3813 case strings.EqualFold("ValidationException", errorCode): 3814 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3815 3816 default: 3817 genericError := &smithy.GenericAPIError{ 3818 Code: errorCode, 3819 Message: errorMessage, 3820 } 3821 return genericError 3822 3823 } 3824} 3825 3826func awsRestjson1_deserializeOpDocumentGetClassificationExportConfigurationOutput(v **GetClassificationExportConfigurationOutput, value interface{}) error { 3827 if v == nil { 3828 return fmt.Errorf("unexpected nil of type %T", v) 3829 } 3830 if value == nil { 3831 return nil 3832 } 3833 3834 shape, ok := value.(map[string]interface{}) 3835 if !ok { 3836 return fmt.Errorf("unexpected JSON type %v", value) 3837 } 3838 3839 var sv *GetClassificationExportConfigurationOutput 3840 if *v == nil { 3841 sv = &GetClassificationExportConfigurationOutput{} 3842 } else { 3843 sv = *v 3844 } 3845 3846 for key, value := range shape { 3847 switch key { 3848 case "configuration": 3849 if err := awsRestjson1_deserializeDocumentClassificationExportConfiguration(&sv.Configuration, value); err != nil { 3850 return err 3851 } 3852 3853 default: 3854 _, _ = key, value 3855 3856 } 3857 } 3858 *v = sv 3859 return nil 3860} 3861 3862type awsRestjson1_deserializeOpGetCustomDataIdentifier struct { 3863} 3864 3865func (*awsRestjson1_deserializeOpGetCustomDataIdentifier) ID() string { 3866 return "OperationDeserializer" 3867} 3868 3869func (m *awsRestjson1_deserializeOpGetCustomDataIdentifier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3870 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3871) { 3872 out, metadata, err = next.HandleDeserialize(ctx, in) 3873 if err != nil { 3874 return out, metadata, err 3875 } 3876 3877 response, ok := out.RawResponse.(*smithyhttp.Response) 3878 if !ok { 3879 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3880 } 3881 3882 if response.StatusCode < 200 || response.StatusCode >= 300 { 3883 return out, metadata, awsRestjson1_deserializeOpErrorGetCustomDataIdentifier(response, &metadata) 3884 } 3885 output := &GetCustomDataIdentifierOutput{} 3886 out.Result = output 3887 3888 var buff [1024]byte 3889 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3890 3891 body := io.TeeReader(response.Body, ringBuffer) 3892 3893 decoder := json.NewDecoder(body) 3894 decoder.UseNumber() 3895 var shape interface{} 3896 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3897 var snapshot bytes.Buffer 3898 io.Copy(&snapshot, ringBuffer) 3899 err = &smithy.DeserializationError{ 3900 Err: fmt.Errorf("failed to decode response body, %w", err), 3901 Snapshot: snapshot.Bytes(), 3902 } 3903 return out, metadata, err 3904 } 3905 3906 err = awsRestjson1_deserializeOpDocumentGetCustomDataIdentifierOutput(&output, shape) 3907 if err != nil { 3908 var snapshot bytes.Buffer 3909 io.Copy(&snapshot, ringBuffer) 3910 return out, metadata, &smithy.DeserializationError{ 3911 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3912 Snapshot: snapshot.Bytes(), 3913 } 3914 } 3915 3916 return out, metadata, err 3917} 3918 3919func awsRestjson1_deserializeOpErrorGetCustomDataIdentifier(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3920 var errorBuffer bytes.Buffer 3921 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3922 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3923 } 3924 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3925 3926 errorCode := "UnknownError" 3927 errorMessage := errorCode 3928 3929 code := response.Header.Get("X-Amzn-ErrorType") 3930 if len(code) != 0 { 3931 errorCode = restjson.SanitizeErrorCode(code) 3932 } 3933 3934 var buff [1024]byte 3935 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3936 3937 body := io.TeeReader(errorBody, ringBuffer) 3938 decoder := json.NewDecoder(body) 3939 decoder.UseNumber() 3940 code, message, err := restjson.GetErrorInfo(decoder) 3941 if err != nil { 3942 var snapshot bytes.Buffer 3943 io.Copy(&snapshot, ringBuffer) 3944 err = &smithy.DeserializationError{ 3945 Err: fmt.Errorf("failed to decode response body, %w", err), 3946 Snapshot: snapshot.Bytes(), 3947 } 3948 return err 3949 } 3950 3951 errorBody.Seek(0, io.SeekStart) 3952 if len(code) != 0 { 3953 errorCode = restjson.SanitizeErrorCode(code) 3954 } 3955 if len(message) != 0 { 3956 errorMessage = message 3957 } 3958 3959 switch { 3960 case strings.EqualFold("AccessDeniedException", errorCode): 3961 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3962 3963 case strings.EqualFold("ConflictException", errorCode): 3964 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3965 3966 case strings.EqualFold("InternalServerException", errorCode): 3967 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3968 3969 case strings.EqualFold("ResourceNotFoundException", errorCode): 3970 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3971 3972 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 3973 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 3974 3975 case strings.EqualFold("ThrottlingException", errorCode): 3976 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3977 3978 case strings.EqualFold("ValidationException", errorCode): 3979 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3980 3981 default: 3982 genericError := &smithy.GenericAPIError{ 3983 Code: errorCode, 3984 Message: errorMessage, 3985 } 3986 return genericError 3987 3988 } 3989} 3990 3991func awsRestjson1_deserializeOpDocumentGetCustomDataIdentifierOutput(v **GetCustomDataIdentifierOutput, value interface{}) error { 3992 if v == nil { 3993 return fmt.Errorf("unexpected nil of type %T", v) 3994 } 3995 if value == nil { 3996 return nil 3997 } 3998 3999 shape, ok := value.(map[string]interface{}) 4000 if !ok { 4001 return fmt.Errorf("unexpected JSON type %v", value) 4002 } 4003 4004 var sv *GetCustomDataIdentifierOutput 4005 if *v == nil { 4006 sv = &GetCustomDataIdentifierOutput{} 4007 } else { 4008 sv = *v 4009 } 4010 4011 for key, value := range shape { 4012 switch key { 4013 case "arn": 4014 if value != nil { 4015 jtv, ok := value.(string) 4016 if !ok { 4017 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4018 } 4019 sv.Arn = ptr.String(jtv) 4020 } 4021 4022 case "createdAt": 4023 if value != nil { 4024 jtv, ok := value.(string) 4025 if !ok { 4026 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 4027 } 4028 t, err := smithytime.ParseDateTime(jtv) 4029 if err != nil { 4030 return err 4031 } 4032 sv.CreatedAt = ptr.Time(t) 4033 } 4034 4035 case "deleted": 4036 if value != nil { 4037 jtv, ok := value.(bool) 4038 if !ok { 4039 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 4040 } 4041 sv.Deleted = jtv 4042 } 4043 4044 case "description": 4045 if value != nil { 4046 jtv, ok := value.(string) 4047 if !ok { 4048 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4049 } 4050 sv.Description = ptr.String(jtv) 4051 } 4052 4053 case "id": 4054 if value != nil { 4055 jtv, ok := value.(string) 4056 if !ok { 4057 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4058 } 4059 sv.Id = ptr.String(jtv) 4060 } 4061 4062 case "ignoreWords": 4063 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.IgnoreWords, value); err != nil { 4064 return err 4065 } 4066 4067 case "keywords": 4068 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Keywords, value); err != nil { 4069 return err 4070 } 4071 4072 case "maximumMatchDistance": 4073 if value != nil { 4074 jtv, ok := value.(json.Number) 4075 if !ok { 4076 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 4077 } 4078 i64, err := jtv.Int64() 4079 if err != nil { 4080 return err 4081 } 4082 sv.MaximumMatchDistance = int32(i64) 4083 } 4084 4085 case "name": 4086 if value != nil { 4087 jtv, ok := value.(string) 4088 if !ok { 4089 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4090 } 4091 sv.Name = ptr.String(jtv) 4092 } 4093 4094 case "regex": 4095 if value != nil { 4096 jtv, ok := value.(string) 4097 if !ok { 4098 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4099 } 4100 sv.Regex = ptr.String(jtv) 4101 } 4102 4103 case "tags": 4104 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 4105 return err 4106 } 4107 4108 default: 4109 _, _ = key, value 4110 4111 } 4112 } 4113 *v = sv 4114 return nil 4115} 4116 4117type awsRestjson1_deserializeOpGetFindings struct { 4118} 4119 4120func (*awsRestjson1_deserializeOpGetFindings) ID() string { 4121 return "OperationDeserializer" 4122} 4123 4124func (m *awsRestjson1_deserializeOpGetFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4125 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4126) { 4127 out, metadata, err = next.HandleDeserialize(ctx, in) 4128 if err != nil { 4129 return out, metadata, err 4130 } 4131 4132 response, ok := out.RawResponse.(*smithyhttp.Response) 4133 if !ok { 4134 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4135 } 4136 4137 if response.StatusCode < 200 || response.StatusCode >= 300 { 4138 return out, metadata, awsRestjson1_deserializeOpErrorGetFindings(response, &metadata) 4139 } 4140 output := &GetFindingsOutput{} 4141 out.Result = output 4142 4143 var buff [1024]byte 4144 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4145 4146 body := io.TeeReader(response.Body, ringBuffer) 4147 4148 decoder := json.NewDecoder(body) 4149 decoder.UseNumber() 4150 var shape interface{} 4151 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4152 var snapshot bytes.Buffer 4153 io.Copy(&snapshot, ringBuffer) 4154 err = &smithy.DeserializationError{ 4155 Err: fmt.Errorf("failed to decode response body, %w", err), 4156 Snapshot: snapshot.Bytes(), 4157 } 4158 return out, metadata, err 4159 } 4160 4161 err = awsRestjson1_deserializeOpDocumentGetFindingsOutput(&output, shape) 4162 if err != nil { 4163 var snapshot bytes.Buffer 4164 io.Copy(&snapshot, ringBuffer) 4165 return out, metadata, &smithy.DeserializationError{ 4166 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4167 Snapshot: snapshot.Bytes(), 4168 } 4169 } 4170 4171 return out, metadata, err 4172} 4173 4174func awsRestjson1_deserializeOpErrorGetFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4175 var errorBuffer bytes.Buffer 4176 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4177 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4178 } 4179 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4180 4181 errorCode := "UnknownError" 4182 errorMessage := errorCode 4183 4184 code := response.Header.Get("X-Amzn-ErrorType") 4185 if len(code) != 0 { 4186 errorCode = restjson.SanitizeErrorCode(code) 4187 } 4188 4189 var buff [1024]byte 4190 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4191 4192 body := io.TeeReader(errorBody, ringBuffer) 4193 decoder := json.NewDecoder(body) 4194 decoder.UseNumber() 4195 code, message, err := restjson.GetErrorInfo(decoder) 4196 if err != nil { 4197 var snapshot bytes.Buffer 4198 io.Copy(&snapshot, ringBuffer) 4199 err = &smithy.DeserializationError{ 4200 Err: fmt.Errorf("failed to decode response body, %w", err), 4201 Snapshot: snapshot.Bytes(), 4202 } 4203 return err 4204 } 4205 4206 errorBody.Seek(0, io.SeekStart) 4207 if len(code) != 0 { 4208 errorCode = restjson.SanitizeErrorCode(code) 4209 } 4210 if len(message) != 0 { 4211 errorMessage = message 4212 } 4213 4214 switch { 4215 case strings.EqualFold("AccessDeniedException", errorCode): 4216 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4217 4218 case strings.EqualFold("ConflictException", errorCode): 4219 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4220 4221 case strings.EqualFold("InternalServerException", errorCode): 4222 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4223 4224 case strings.EqualFold("ResourceNotFoundException", errorCode): 4225 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4226 4227 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4228 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4229 4230 case strings.EqualFold("ThrottlingException", errorCode): 4231 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4232 4233 case strings.EqualFold("ValidationException", errorCode): 4234 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4235 4236 default: 4237 genericError := &smithy.GenericAPIError{ 4238 Code: errorCode, 4239 Message: errorMessage, 4240 } 4241 return genericError 4242 4243 } 4244} 4245 4246func awsRestjson1_deserializeOpDocumentGetFindingsOutput(v **GetFindingsOutput, value interface{}) error { 4247 if v == nil { 4248 return fmt.Errorf("unexpected nil of type %T", v) 4249 } 4250 if value == nil { 4251 return nil 4252 } 4253 4254 shape, ok := value.(map[string]interface{}) 4255 if !ok { 4256 return fmt.Errorf("unexpected JSON type %v", value) 4257 } 4258 4259 var sv *GetFindingsOutput 4260 if *v == nil { 4261 sv = &GetFindingsOutput{} 4262 } else { 4263 sv = *v 4264 } 4265 4266 for key, value := range shape { 4267 switch key { 4268 case "findings": 4269 if err := awsRestjson1_deserializeDocument__listOfFinding(&sv.Findings, value); err != nil { 4270 return err 4271 } 4272 4273 default: 4274 _, _ = key, value 4275 4276 } 4277 } 4278 *v = sv 4279 return nil 4280} 4281 4282type awsRestjson1_deserializeOpGetFindingsFilter struct { 4283} 4284 4285func (*awsRestjson1_deserializeOpGetFindingsFilter) ID() string { 4286 return "OperationDeserializer" 4287} 4288 4289func (m *awsRestjson1_deserializeOpGetFindingsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4290 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4291) { 4292 out, metadata, err = next.HandleDeserialize(ctx, in) 4293 if err != nil { 4294 return out, metadata, err 4295 } 4296 4297 response, ok := out.RawResponse.(*smithyhttp.Response) 4298 if !ok { 4299 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4300 } 4301 4302 if response.StatusCode < 200 || response.StatusCode >= 300 { 4303 return out, metadata, awsRestjson1_deserializeOpErrorGetFindingsFilter(response, &metadata) 4304 } 4305 output := &GetFindingsFilterOutput{} 4306 out.Result = output 4307 4308 var buff [1024]byte 4309 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4310 4311 body := io.TeeReader(response.Body, ringBuffer) 4312 4313 decoder := json.NewDecoder(body) 4314 decoder.UseNumber() 4315 var shape interface{} 4316 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4317 var snapshot bytes.Buffer 4318 io.Copy(&snapshot, ringBuffer) 4319 err = &smithy.DeserializationError{ 4320 Err: fmt.Errorf("failed to decode response body, %w", err), 4321 Snapshot: snapshot.Bytes(), 4322 } 4323 return out, metadata, err 4324 } 4325 4326 err = awsRestjson1_deserializeOpDocumentGetFindingsFilterOutput(&output, shape) 4327 if err != nil { 4328 var snapshot bytes.Buffer 4329 io.Copy(&snapshot, ringBuffer) 4330 return out, metadata, &smithy.DeserializationError{ 4331 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4332 Snapshot: snapshot.Bytes(), 4333 } 4334 } 4335 4336 return out, metadata, err 4337} 4338 4339func awsRestjson1_deserializeOpErrorGetFindingsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4340 var errorBuffer bytes.Buffer 4341 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4342 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4343 } 4344 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4345 4346 errorCode := "UnknownError" 4347 errorMessage := errorCode 4348 4349 code := response.Header.Get("X-Amzn-ErrorType") 4350 if len(code) != 0 { 4351 errorCode = restjson.SanitizeErrorCode(code) 4352 } 4353 4354 var buff [1024]byte 4355 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4356 4357 body := io.TeeReader(errorBody, ringBuffer) 4358 decoder := json.NewDecoder(body) 4359 decoder.UseNumber() 4360 code, message, err := restjson.GetErrorInfo(decoder) 4361 if err != nil { 4362 var snapshot bytes.Buffer 4363 io.Copy(&snapshot, ringBuffer) 4364 err = &smithy.DeserializationError{ 4365 Err: fmt.Errorf("failed to decode response body, %w", err), 4366 Snapshot: snapshot.Bytes(), 4367 } 4368 return err 4369 } 4370 4371 errorBody.Seek(0, io.SeekStart) 4372 if len(code) != 0 { 4373 errorCode = restjson.SanitizeErrorCode(code) 4374 } 4375 if len(message) != 0 { 4376 errorMessage = message 4377 } 4378 4379 switch { 4380 case strings.EqualFold("AccessDeniedException", errorCode): 4381 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4382 4383 case strings.EqualFold("ConflictException", errorCode): 4384 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4385 4386 case strings.EqualFold("InternalServerException", errorCode): 4387 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4388 4389 case strings.EqualFold("ResourceNotFoundException", errorCode): 4390 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4391 4392 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4393 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4394 4395 case strings.EqualFold("ThrottlingException", errorCode): 4396 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4397 4398 case strings.EqualFold("ValidationException", errorCode): 4399 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4400 4401 default: 4402 genericError := &smithy.GenericAPIError{ 4403 Code: errorCode, 4404 Message: errorMessage, 4405 } 4406 return genericError 4407 4408 } 4409} 4410 4411func awsRestjson1_deserializeOpDocumentGetFindingsFilterOutput(v **GetFindingsFilterOutput, value interface{}) error { 4412 if v == nil { 4413 return fmt.Errorf("unexpected nil of type %T", v) 4414 } 4415 if value == nil { 4416 return nil 4417 } 4418 4419 shape, ok := value.(map[string]interface{}) 4420 if !ok { 4421 return fmt.Errorf("unexpected JSON type %v", value) 4422 } 4423 4424 var sv *GetFindingsFilterOutput 4425 if *v == nil { 4426 sv = &GetFindingsFilterOutput{} 4427 } else { 4428 sv = *v 4429 } 4430 4431 for key, value := range shape { 4432 switch key { 4433 case "action": 4434 if value != nil { 4435 jtv, ok := value.(string) 4436 if !ok { 4437 return fmt.Errorf("expected FindingsFilterAction to be of type string, got %T instead", value) 4438 } 4439 sv.Action = types.FindingsFilterAction(jtv) 4440 } 4441 4442 case "arn": 4443 if value != nil { 4444 jtv, ok := value.(string) 4445 if !ok { 4446 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4447 } 4448 sv.Arn = ptr.String(jtv) 4449 } 4450 4451 case "description": 4452 if value != nil { 4453 jtv, ok := value.(string) 4454 if !ok { 4455 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4456 } 4457 sv.Description = ptr.String(jtv) 4458 } 4459 4460 case "findingCriteria": 4461 if err := awsRestjson1_deserializeDocumentFindingCriteria(&sv.FindingCriteria, value); err != nil { 4462 return err 4463 } 4464 4465 case "id": 4466 if value != nil { 4467 jtv, ok := value.(string) 4468 if !ok { 4469 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4470 } 4471 sv.Id = ptr.String(jtv) 4472 } 4473 4474 case "name": 4475 if value != nil { 4476 jtv, ok := value.(string) 4477 if !ok { 4478 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4479 } 4480 sv.Name = ptr.String(jtv) 4481 } 4482 4483 case "position": 4484 if value != nil { 4485 jtv, ok := value.(json.Number) 4486 if !ok { 4487 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 4488 } 4489 i64, err := jtv.Int64() 4490 if err != nil { 4491 return err 4492 } 4493 sv.Position = int32(i64) 4494 } 4495 4496 case "tags": 4497 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 4498 return err 4499 } 4500 4501 default: 4502 _, _ = key, value 4503 4504 } 4505 } 4506 *v = sv 4507 return nil 4508} 4509 4510type awsRestjson1_deserializeOpGetFindingsPublicationConfiguration struct { 4511} 4512 4513func (*awsRestjson1_deserializeOpGetFindingsPublicationConfiguration) ID() string { 4514 return "OperationDeserializer" 4515} 4516 4517func (m *awsRestjson1_deserializeOpGetFindingsPublicationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4518 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4519) { 4520 out, metadata, err = next.HandleDeserialize(ctx, in) 4521 if err != nil { 4522 return out, metadata, err 4523 } 4524 4525 response, ok := out.RawResponse.(*smithyhttp.Response) 4526 if !ok { 4527 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4528 } 4529 4530 if response.StatusCode < 200 || response.StatusCode >= 300 { 4531 return out, metadata, awsRestjson1_deserializeOpErrorGetFindingsPublicationConfiguration(response, &metadata) 4532 } 4533 output := &GetFindingsPublicationConfigurationOutput{} 4534 out.Result = output 4535 4536 var buff [1024]byte 4537 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4538 4539 body := io.TeeReader(response.Body, ringBuffer) 4540 4541 decoder := json.NewDecoder(body) 4542 decoder.UseNumber() 4543 var shape interface{} 4544 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4545 var snapshot bytes.Buffer 4546 io.Copy(&snapshot, ringBuffer) 4547 err = &smithy.DeserializationError{ 4548 Err: fmt.Errorf("failed to decode response body, %w", err), 4549 Snapshot: snapshot.Bytes(), 4550 } 4551 return out, metadata, err 4552 } 4553 4554 err = awsRestjson1_deserializeOpDocumentGetFindingsPublicationConfigurationOutput(&output, shape) 4555 if err != nil { 4556 var snapshot bytes.Buffer 4557 io.Copy(&snapshot, ringBuffer) 4558 return out, metadata, &smithy.DeserializationError{ 4559 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4560 Snapshot: snapshot.Bytes(), 4561 } 4562 } 4563 4564 return out, metadata, err 4565} 4566 4567func awsRestjson1_deserializeOpErrorGetFindingsPublicationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4568 var errorBuffer bytes.Buffer 4569 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4570 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4571 } 4572 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4573 4574 errorCode := "UnknownError" 4575 errorMessage := errorCode 4576 4577 code := response.Header.Get("X-Amzn-ErrorType") 4578 if len(code) != 0 { 4579 errorCode = restjson.SanitizeErrorCode(code) 4580 } 4581 4582 var buff [1024]byte 4583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4584 4585 body := io.TeeReader(errorBody, ringBuffer) 4586 decoder := json.NewDecoder(body) 4587 decoder.UseNumber() 4588 code, message, err := restjson.GetErrorInfo(decoder) 4589 if err != nil { 4590 var snapshot bytes.Buffer 4591 io.Copy(&snapshot, ringBuffer) 4592 err = &smithy.DeserializationError{ 4593 Err: fmt.Errorf("failed to decode response body, %w", err), 4594 Snapshot: snapshot.Bytes(), 4595 } 4596 return err 4597 } 4598 4599 errorBody.Seek(0, io.SeekStart) 4600 if len(code) != 0 { 4601 errorCode = restjson.SanitizeErrorCode(code) 4602 } 4603 if len(message) != 0 { 4604 errorMessage = message 4605 } 4606 4607 switch { 4608 case strings.EqualFold("AccessDeniedException", errorCode): 4609 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4610 4611 case strings.EqualFold("ConflictException", errorCode): 4612 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4613 4614 case strings.EqualFold("InternalServerException", errorCode): 4615 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4616 4617 case strings.EqualFold("ResourceNotFoundException", errorCode): 4618 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4619 4620 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4621 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4622 4623 case strings.EqualFold("ThrottlingException", errorCode): 4624 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4625 4626 case strings.EqualFold("ValidationException", errorCode): 4627 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4628 4629 default: 4630 genericError := &smithy.GenericAPIError{ 4631 Code: errorCode, 4632 Message: errorMessage, 4633 } 4634 return genericError 4635 4636 } 4637} 4638 4639func awsRestjson1_deserializeOpDocumentGetFindingsPublicationConfigurationOutput(v **GetFindingsPublicationConfigurationOutput, value interface{}) error { 4640 if v == nil { 4641 return fmt.Errorf("unexpected nil of type %T", v) 4642 } 4643 if value == nil { 4644 return nil 4645 } 4646 4647 shape, ok := value.(map[string]interface{}) 4648 if !ok { 4649 return fmt.Errorf("unexpected JSON type %v", value) 4650 } 4651 4652 var sv *GetFindingsPublicationConfigurationOutput 4653 if *v == nil { 4654 sv = &GetFindingsPublicationConfigurationOutput{} 4655 } else { 4656 sv = *v 4657 } 4658 4659 for key, value := range shape { 4660 switch key { 4661 case "securityHubConfiguration": 4662 if err := awsRestjson1_deserializeDocumentSecurityHubConfiguration(&sv.SecurityHubConfiguration, value); err != nil { 4663 return err 4664 } 4665 4666 default: 4667 _, _ = key, value 4668 4669 } 4670 } 4671 *v = sv 4672 return nil 4673} 4674 4675type awsRestjson1_deserializeOpGetFindingStatistics struct { 4676} 4677 4678func (*awsRestjson1_deserializeOpGetFindingStatistics) ID() string { 4679 return "OperationDeserializer" 4680} 4681 4682func (m *awsRestjson1_deserializeOpGetFindingStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4683 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4684) { 4685 out, metadata, err = next.HandleDeserialize(ctx, in) 4686 if err != nil { 4687 return out, metadata, err 4688 } 4689 4690 response, ok := out.RawResponse.(*smithyhttp.Response) 4691 if !ok { 4692 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4693 } 4694 4695 if response.StatusCode < 200 || response.StatusCode >= 300 { 4696 return out, metadata, awsRestjson1_deserializeOpErrorGetFindingStatistics(response, &metadata) 4697 } 4698 output := &GetFindingStatisticsOutput{} 4699 out.Result = output 4700 4701 var buff [1024]byte 4702 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4703 4704 body := io.TeeReader(response.Body, ringBuffer) 4705 4706 decoder := json.NewDecoder(body) 4707 decoder.UseNumber() 4708 var shape interface{} 4709 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4710 var snapshot bytes.Buffer 4711 io.Copy(&snapshot, ringBuffer) 4712 err = &smithy.DeserializationError{ 4713 Err: fmt.Errorf("failed to decode response body, %w", err), 4714 Snapshot: snapshot.Bytes(), 4715 } 4716 return out, metadata, err 4717 } 4718 4719 err = awsRestjson1_deserializeOpDocumentGetFindingStatisticsOutput(&output, shape) 4720 if err != nil { 4721 var snapshot bytes.Buffer 4722 io.Copy(&snapshot, ringBuffer) 4723 return out, metadata, &smithy.DeserializationError{ 4724 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4725 Snapshot: snapshot.Bytes(), 4726 } 4727 } 4728 4729 return out, metadata, err 4730} 4731 4732func awsRestjson1_deserializeOpErrorGetFindingStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4733 var errorBuffer bytes.Buffer 4734 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4735 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4736 } 4737 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4738 4739 errorCode := "UnknownError" 4740 errorMessage := errorCode 4741 4742 code := response.Header.Get("X-Amzn-ErrorType") 4743 if len(code) != 0 { 4744 errorCode = restjson.SanitizeErrorCode(code) 4745 } 4746 4747 var buff [1024]byte 4748 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4749 4750 body := io.TeeReader(errorBody, ringBuffer) 4751 decoder := json.NewDecoder(body) 4752 decoder.UseNumber() 4753 code, message, err := restjson.GetErrorInfo(decoder) 4754 if err != nil { 4755 var snapshot bytes.Buffer 4756 io.Copy(&snapshot, ringBuffer) 4757 err = &smithy.DeserializationError{ 4758 Err: fmt.Errorf("failed to decode response body, %w", err), 4759 Snapshot: snapshot.Bytes(), 4760 } 4761 return err 4762 } 4763 4764 errorBody.Seek(0, io.SeekStart) 4765 if len(code) != 0 { 4766 errorCode = restjson.SanitizeErrorCode(code) 4767 } 4768 if len(message) != 0 { 4769 errorMessage = message 4770 } 4771 4772 switch { 4773 case strings.EqualFold("AccessDeniedException", errorCode): 4774 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4775 4776 case strings.EqualFold("ConflictException", errorCode): 4777 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4778 4779 case strings.EqualFold("InternalServerException", errorCode): 4780 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4781 4782 case strings.EqualFold("ResourceNotFoundException", errorCode): 4783 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4784 4785 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4786 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4787 4788 case strings.EqualFold("ThrottlingException", errorCode): 4789 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4790 4791 case strings.EqualFold("ValidationException", errorCode): 4792 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4793 4794 default: 4795 genericError := &smithy.GenericAPIError{ 4796 Code: errorCode, 4797 Message: errorMessage, 4798 } 4799 return genericError 4800 4801 } 4802} 4803 4804func awsRestjson1_deserializeOpDocumentGetFindingStatisticsOutput(v **GetFindingStatisticsOutput, value interface{}) error { 4805 if v == nil { 4806 return fmt.Errorf("unexpected nil of type %T", v) 4807 } 4808 if value == nil { 4809 return nil 4810 } 4811 4812 shape, ok := value.(map[string]interface{}) 4813 if !ok { 4814 return fmt.Errorf("unexpected JSON type %v", value) 4815 } 4816 4817 var sv *GetFindingStatisticsOutput 4818 if *v == nil { 4819 sv = &GetFindingStatisticsOutput{} 4820 } else { 4821 sv = *v 4822 } 4823 4824 for key, value := range shape { 4825 switch key { 4826 case "countsByGroup": 4827 if err := awsRestjson1_deserializeDocument__listOfGroupCount(&sv.CountsByGroup, value); err != nil { 4828 return err 4829 } 4830 4831 default: 4832 _, _ = key, value 4833 4834 } 4835 } 4836 *v = sv 4837 return nil 4838} 4839 4840type awsRestjson1_deserializeOpGetInvitationsCount struct { 4841} 4842 4843func (*awsRestjson1_deserializeOpGetInvitationsCount) ID() string { 4844 return "OperationDeserializer" 4845} 4846 4847func (m *awsRestjson1_deserializeOpGetInvitationsCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4848 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4849) { 4850 out, metadata, err = next.HandleDeserialize(ctx, in) 4851 if err != nil { 4852 return out, metadata, err 4853 } 4854 4855 response, ok := out.RawResponse.(*smithyhttp.Response) 4856 if !ok { 4857 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4858 } 4859 4860 if response.StatusCode < 200 || response.StatusCode >= 300 { 4861 return out, metadata, awsRestjson1_deserializeOpErrorGetInvitationsCount(response, &metadata) 4862 } 4863 output := &GetInvitationsCountOutput{} 4864 out.Result = output 4865 4866 var buff [1024]byte 4867 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4868 4869 body := io.TeeReader(response.Body, ringBuffer) 4870 4871 decoder := json.NewDecoder(body) 4872 decoder.UseNumber() 4873 var shape interface{} 4874 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4875 var snapshot bytes.Buffer 4876 io.Copy(&snapshot, ringBuffer) 4877 err = &smithy.DeserializationError{ 4878 Err: fmt.Errorf("failed to decode response body, %w", err), 4879 Snapshot: snapshot.Bytes(), 4880 } 4881 return out, metadata, err 4882 } 4883 4884 err = awsRestjson1_deserializeOpDocumentGetInvitationsCountOutput(&output, shape) 4885 if err != nil { 4886 var snapshot bytes.Buffer 4887 io.Copy(&snapshot, ringBuffer) 4888 return out, metadata, &smithy.DeserializationError{ 4889 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4890 Snapshot: snapshot.Bytes(), 4891 } 4892 } 4893 4894 return out, metadata, err 4895} 4896 4897func awsRestjson1_deserializeOpErrorGetInvitationsCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4898 var errorBuffer bytes.Buffer 4899 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4900 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4901 } 4902 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4903 4904 errorCode := "UnknownError" 4905 errorMessage := errorCode 4906 4907 code := response.Header.Get("X-Amzn-ErrorType") 4908 if len(code) != 0 { 4909 errorCode = restjson.SanitizeErrorCode(code) 4910 } 4911 4912 var buff [1024]byte 4913 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4914 4915 body := io.TeeReader(errorBody, ringBuffer) 4916 decoder := json.NewDecoder(body) 4917 decoder.UseNumber() 4918 code, message, err := restjson.GetErrorInfo(decoder) 4919 if err != nil { 4920 var snapshot bytes.Buffer 4921 io.Copy(&snapshot, ringBuffer) 4922 err = &smithy.DeserializationError{ 4923 Err: fmt.Errorf("failed to decode response body, %w", err), 4924 Snapshot: snapshot.Bytes(), 4925 } 4926 return err 4927 } 4928 4929 errorBody.Seek(0, io.SeekStart) 4930 if len(code) != 0 { 4931 errorCode = restjson.SanitizeErrorCode(code) 4932 } 4933 if len(message) != 0 { 4934 errorMessage = message 4935 } 4936 4937 switch { 4938 case strings.EqualFold("AccessDeniedException", errorCode): 4939 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4940 4941 case strings.EqualFold("ConflictException", errorCode): 4942 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 4943 4944 case strings.EqualFold("InternalServerException", errorCode): 4945 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4946 4947 case strings.EqualFold("ResourceNotFoundException", errorCode): 4948 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4949 4950 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 4951 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 4952 4953 case strings.EqualFold("ThrottlingException", errorCode): 4954 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4955 4956 case strings.EqualFold("ValidationException", errorCode): 4957 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4958 4959 default: 4960 genericError := &smithy.GenericAPIError{ 4961 Code: errorCode, 4962 Message: errorMessage, 4963 } 4964 return genericError 4965 4966 } 4967} 4968 4969func awsRestjson1_deserializeOpDocumentGetInvitationsCountOutput(v **GetInvitationsCountOutput, value interface{}) error { 4970 if v == nil { 4971 return fmt.Errorf("unexpected nil of type %T", v) 4972 } 4973 if value == nil { 4974 return nil 4975 } 4976 4977 shape, ok := value.(map[string]interface{}) 4978 if !ok { 4979 return fmt.Errorf("unexpected JSON type %v", value) 4980 } 4981 4982 var sv *GetInvitationsCountOutput 4983 if *v == nil { 4984 sv = &GetInvitationsCountOutput{} 4985 } else { 4986 sv = *v 4987 } 4988 4989 for key, value := range shape { 4990 switch key { 4991 case "invitationsCount": 4992 if value != nil { 4993 jtv, ok := value.(json.Number) 4994 if !ok { 4995 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 4996 } 4997 i64, err := jtv.Int64() 4998 if err != nil { 4999 return err 5000 } 5001 sv.InvitationsCount = i64 5002 } 5003 5004 default: 5005 _, _ = key, value 5006 5007 } 5008 } 5009 *v = sv 5010 return nil 5011} 5012 5013type awsRestjson1_deserializeOpGetMacieSession struct { 5014} 5015 5016func (*awsRestjson1_deserializeOpGetMacieSession) ID() string { 5017 return "OperationDeserializer" 5018} 5019 5020func (m *awsRestjson1_deserializeOpGetMacieSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5021 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5022) { 5023 out, metadata, err = next.HandleDeserialize(ctx, in) 5024 if err != nil { 5025 return out, metadata, err 5026 } 5027 5028 response, ok := out.RawResponse.(*smithyhttp.Response) 5029 if !ok { 5030 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5031 } 5032 5033 if response.StatusCode < 200 || response.StatusCode >= 300 { 5034 return out, metadata, awsRestjson1_deserializeOpErrorGetMacieSession(response, &metadata) 5035 } 5036 output := &GetMacieSessionOutput{} 5037 out.Result = output 5038 5039 var buff [1024]byte 5040 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5041 5042 body := io.TeeReader(response.Body, ringBuffer) 5043 5044 decoder := json.NewDecoder(body) 5045 decoder.UseNumber() 5046 var shape interface{} 5047 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5048 var snapshot bytes.Buffer 5049 io.Copy(&snapshot, ringBuffer) 5050 err = &smithy.DeserializationError{ 5051 Err: fmt.Errorf("failed to decode response body, %w", err), 5052 Snapshot: snapshot.Bytes(), 5053 } 5054 return out, metadata, err 5055 } 5056 5057 err = awsRestjson1_deserializeOpDocumentGetMacieSessionOutput(&output, shape) 5058 if err != nil { 5059 var snapshot bytes.Buffer 5060 io.Copy(&snapshot, ringBuffer) 5061 return out, metadata, &smithy.DeserializationError{ 5062 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5063 Snapshot: snapshot.Bytes(), 5064 } 5065 } 5066 5067 return out, metadata, err 5068} 5069 5070func awsRestjson1_deserializeOpErrorGetMacieSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5071 var errorBuffer bytes.Buffer 5072 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5073 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5074 } 5075 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5076 5077 errorCode := "UnknownError" 5078 errorMessage := errorCode 5079 5080 code := response.Header.Get("X-Amzn-ErrorType") 5081 if len(code) != 0 { 5082 errorCode = restjson.SanitizeErrorCode(code) 5083 } 5084 5085 var buff [1024]byte 5086 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5087 5088 body := io.TeeReader(errorBody, ringBuffer) 5089 decoder := json.NewDecoder(body) 5090 decoder.UseNumber() 5091 code, message, err := restjson.GetErrorInfo(decoder) 5092 if err != nil { 5093 var snapshot bytes.Buffer 5094 io.Copy(&snapshot, ringBuffer) 5095 err = &smithy.DeserializationError{ 5096 Err: fmt.Errorf("failed to decode response body, %w", err), 5097 Snapshot: snapshot.Bytes(), 5098 } 5099 return err 5100 } 5101 5102 errorBody.Seek(0, io.SeekStart) 5103 if len(code) != 0 { 5104 errorCode = restjson.SanitizeErrorCode(code) 5105 } 5106 if len(message) != 0 { 5107 errorMessage = message 5108 } 5109 5110 switch { 5111 case strings.EqualFold("AccessDeniedException", errorCode): 5112 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5113 5114 case strings.EqualFold("ConflictException", errorCode): 5115 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5116 5117 case strings.EqualFold("InternalServerException", errorCode): 5118 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5119 5120 case strings.EqualFold("ResourceNotFoundException", errorCode): 5121 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5122 5123 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5124 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5125 5126 case strings.EqualFold("ThrottlingException", errorCode): 5127 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5128 5129 case strings.EqualFold("ValidationException", errorCode): 5130 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5131 5132 default: 5133 genericError := &smithy.GenericAPIError{ 5134 Code: errorCode, 5135 Message: errorMessage, 5136 } 5137 return genericError 5138 5139 } 5140} 5141 5142func awsRestjson1_deserializeOpDocumentGetMacieSessionOutput(v **GetMacieSessionOutput, value interface{}) error { 5143 if v == nil { 5144 return fmt.Errorf("unexpected nil of type %T", v) 5145 } 5146 if value == nil { 5147 return nil 5148 } 5149 5150 shape, ok := value.(map[string]interface{}) 5151 if !ok { 5152 return fmt.Errorf("unexpected JSON type %v", value) 5153 } 5154 5155 var sv *GetMacieSessionOutput 5156 if *v == nil { 5157 sv = &GetMacieSessionOutput{} 5158 } else { 5159 sv = *v 5160 } 5161 5162 for key, value := range shape { 5163 switch key { 5164 case "createdAt": 5165 if value != nil { 5166 jtv, ok := value.(string) 5167 if !ok { 5168 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 5169 } 5170 t, err := smithytime.ParseDateTime(jtv) 5171 if err != nil { 5172 return err 5173 } 5174 sv.CreatedAt = ptr.Time(t) 5175 } 5176 5177 case "findingPublishingFrequency": 5178 if value != nil { 5179 jtv, ok := value.(string) 5180 if !ok { 5181 return fmt.Errorf("expected FindingPublishingFrequency to be of type string, got %T instead", value) 5182 } 5183 sv.FindingPublishingFrequency = types.FindingPublishingFrequency(jtv) 5184 } 5185 5186 case "serviceRole": 5187 if value != nil { 5188 jtv, ok := value.(string) 5189 if !ok { 5190 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5191 } 5192 sv.ServiceRole = ptr.String(jtv) 5193 } 5194 5195 case "status": 5196 if value != nil { 5197 jtv, ok := value.(string) 5198 if !ok { 5199 return fmt.Errorf("expected MacieStatus to be of type string, got %T instead", value) 5200 } 5201 sv.Status = types.MacieStatus(jtv) 5202 } 5203 5204 case "updatedAt": 5205 if value != nil { 5206 jtv, ok := value.(string) 5207 if !ok { 5208 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 5209 } 5210 t, err := smithytime.ParseDateTime(jtv) 5211 if err != nil { 5212 return err 5213 } 5214 sv.UpdatedAt = ptr.Time(t) 5215 } 5216 5217 default: 5218 _, _ = key, value 5219 5220 } 5221 } 5222 *v = sv 5223 return nil 5224} 5225 5226type awsRestjson1_deserializeOpGetMasterAccount struct { 5227} 5228 5229func (*awsRestjson1_deserializeOpGetMasterAccount) ID() string { 5230 return "OperationDeserializer" 5231} 5232 5233func (m *awsRestjson1_deserializeOpGetMasterAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5234 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5235) { 5236 out, metadata, err = next.HandleDeserialize(ctx, in) 5237 if err != nil { 5238 return out, metadata, err 5239 } 5240 5241 response, ok := out.RawResponse.(*smithyhttp.Response) 5242 if !ok { 5243 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5244 } 5245 5246 if response.StatusCode < 200 || response.StatusCode >= 300 { 5247 return out, metadata, awsRestjson1_deserializeOpErrorGetMasterAccount(response, &metadata) 5248 } 5249 output := &GetMasterAccountOutput{} 5250 out.Result = output 5251 5252 var buff [1024]byte 5253 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5254 5255 body := io.TeeReader(response.Body, ringBuffer) 5256 5257 decoder := json.NewDecoder(body) 5258 decoder.UseNumber() 5259 var shape interface{} 5260 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5261 var snapshot bytes.Buffer 5262 io.Copy(&snapshot, ringBuffer) 5263 err = &smithy.DeserializationError{ 5264 Err: fmt.Errorf("failed to decode response body, %w", err), 5265 Snapshot: snapshot.Bytes(), 5266 } 5267 return out, metadata, err 5268 } 5269 5270 err = awsRestjson1_deserializeOpDocumentGetMasterAccountOutput(&output, shape) 5271 if err != nil { 5272 var snapshot bytes.Buffer 5273 io.Copy(&snapshot, ringBuffer) 5274 return out, metadata, &smithy.DeserializationError{ 5275 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5276 Snapshot: snapshot.Bytes(), 5277 } 5278 } 5279 5280 return out, metadata, err 5281} 5282 5283func awsRestjson1_deserializeOpErrorGetMasterAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5284 var errorBuffer bytes.Buffer 5285 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5286 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5287 } 5288 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5289 5290 errorCode := "UnknownError" 5291 errorMessage := errorCode 5292 5293 code := response.Header.Get("X-Amzn-ErrorType") 5294 if len(code) != 0 { 5295 errorCode = restjson.SanitizeErrorCode(code) 5296 } 5297 5298 var buff [1024]byte 5299 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5300 5301 body := io.TeeReader(errorBody, ringBuffer) 5302 decoder := json.NewDecoder(body) 5303 decoder.UseNumber() 5304 code, message, err := restjson.GetErrorInfo(decoder) 5305 if err != nil { 5306 var snapshot bytes.Buffer 5307 io.Copy(&snapshot, ringBuffer) 5308 err = &smithy.DeserializationError{ 5309 Err: fmt.Errorf("failed to decode response body, %w", err), 5310 Snapshot: snapshot.Bytes(), 5311 } 5312 return err 5313 } 5314 5315 errorBody.Seek(0, io.SeekStart) 5316 if len(code) != 0 { 5317 errorCode = restjson.SanitizeErrorCode(code) 5318 } 5319 if len(message) != 0 { 5320 errorMessage = message 5321 } 5322 5323 switch { 5324 case strings.EqualFold("AccessDeniedException", errorCode): 5325 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5326 5327 case strings.EqualFold("ConflictException", errorCode): 5328 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5329 5330 case strings.EqualFold("InternalServerException", errorCode): 5331 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5332 5333 case strings.EqualFold("ResourceNotFoundException", errorCode): 5334 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5335 5336 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5337 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5338 5339 case strings.EqualFold("ThrottlingException", errorCode): 5340 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5341 5342 case strings.EqualFold("ValidationException", errorCode): 5343 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5344 5345 default: 5346 genericError := &smithy.GenericAPIError{ 5347 Code: errorCode, 5348 Message: errorMessage, 5349 } 5350 return genericError 5351 5352 } 5353} 5354 5355func awsRestjson1_deserializeOpDocumentGetMasterAccountOutput(v **GetMasterAccountOutput, value interface{}) error { 5356 if v == nil { 5357 return fmt.Errorf("unexpected nil of type %T", v) 5358 } 5359 if value == nil { 5360 return nil 5361 } 5362 5363 shape, ok := value.(map[string]interface{}) 5364 if !ok { 5365 return fmt.Errorf("unexpected JSON type %v", value) 5366 } 5367 5368 var sv *GetMasterAccountOutput 5369 if *v == nil { 5370 sv = &GetMasterAccountOutput{} 5371 } else { 5372 sv = *v 5373 } 5374 5375 for key, value := range shape { 5376 switch key { 5377 case "master": 5378 if err := awsRestjson1_deserializeDocumentInvitation(&sv.Master, value); err != nil { 5379 return err 5380 } 5381 5382 default: 5383 _, _ = key, value 5384 5385 } 5386 } 5387 *v = sv 5388 return nil 5389} 5390 5391type awsRestjson1_deserializeOpGetMember struct { 5392} 5393 5394func (*awsRestjson1_deserializeOpGetMember) ID() string { 5395 return "OperationDeserializer" 5396} 5397 5398func (m *awsRestjson1_deserializeOpGetMember) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5399 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5400) { 5401 out, metadata, err = next.HandleDeserialize(ctx, in) 5402 if err != nil { 5403 return out, metadata, err 5404 } 5405 5406 response, ok := out.RawResponse.(*smithyhttp.Response) 5407 if !ok { 5408 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5409 } 5410 5411 if response.StatusCode < 200 || response.StatusCode >= 300 { 5412 return out, metadata, awsRestjson1_deserializeOpErrorGetMember(response, &metadata) 5413 } 5414 output := &GetMemberOutput{} 5415 out.Result = output 5416 5417 var buff [1024]byte 5418 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5419 5420 body := io.TeeReader(response.Body, ringBuffer) 5421 5422 decoder := json.NewDecoder(body) 5423 decoder.UseNumber() 5424 var shape interface{} 5425 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5426 var snapshot bytes.Buffer 5427 io.Copy(&snapshot, ringBuffer) 5428 err = &smithy.DeserializationError{ 5429 Err: fmt.Errorf("failed to decode response body, %w", err), 5430 Snapshot: snapshot.Bytes(), 5431 } 5432 return out, metadata, err 5433 } 5434 5435 err = awsRestjson1_deserializeOpDocumentGetMemberOutput(&output, shape) 5436 if err != nil { 5437 var snapshot bytes.Buffer 5438 io.Copy(&snapshot, ringBuffer) 5439 return out, metadata, &smithy.DeserializationError{ 5440 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5441 Snapshot: snapshot.Bytes(), 5442 } 5443 } 5444 5445 return out, metadata, err 5446} 5447 5448func awsRestjson1_deserializeOpErrorGetMember(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5449 var errorBuffer bytes.Buffer 5450 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5451 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5452 } 5453 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5454 5455 errorCode := "UnknownError" 5456 errorMessage := errorCode 5457 5458 code := response.Header.Get("X-Amzn-ErrorType") 5459 if len(code) != 0 { 5460 errorCode = restjson.SanitizeErrorCode(code) 5461 } 5462 5463 var buff [1024]byte 5464 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5465 5466 body := io.TeeReader(errorBody, ringBuffer) 5467 decoder := json.NewDecoder(body) 5468 decoder.UseNumber() 5469 code, message, err := restjson.GetErrorInfo(decoder) 5470 if err != nil { 5471 var snapshot bytes.Buffer 5472 io.Copy(&snapshot, ringBuffer) 5473 err = &smithy.DeserializationError{ 5474 Err: fmt.Errorf("failed to decode response body, %w", err), 5475 Snapshot: snapshot.Bytes(), 5476 } 5477 return err 5478 } 5479 5480 errorBody.Seek(0, io.SeekStart) 5481 if len(code) != 0 { 5482 errorCode = restjson.SanitizeErrorCode(code) 5483 } 5484 if len(message) != 0 { 5485 errorMessage = message 5486 } 5487 5488 switch { 5489 case strings.EqualFold("AccessDeniedException", errorCode): 5490 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5491 5492 case strings.EqualFold("ConflictException", errorCode): 5493 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5494 5495 case strings.EqualFold("InternalServerException", errorCode): 5496 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5497 5498 case strings.EqualFold("ResourceNotFoundException", errorCode): 5499 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5500 5501 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5502 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5503 5504 case strings.EqualFold("ThrottlingException", errorCode): 5505 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5506 5507 case strings.EqualFold("ValidationException", errorCode): 5508 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5509 5510 default: 5511 genericError := &smithy.GenericAPIError{ 5512 Code: errorCode, 5513 Message: errorMessage, 5514 } 5515 return genericError 5516 5517 } 5518} 5519 5520func awsRestjson1_deserializeOpDocumentGetMemberOutput(v **GetMemberOutput, value interface{}) error { 5521 if v == nil { 5522 return fmt.Errorf("unexpected nil of type %T", v) 5523 } 5524 if value == nil { 5525 return nil 5526 } 5527 5528 shape, ok := value.(map[string]interface{}) 5529 if !ok { 5530 return fmt.Errorf("unexpected JSON type %v", value) 5531 } 5532 5533 var sv *GetMemberOutput 5534 if *v == nil { 5535 sv = &GetMemberOutput{} 5536 } else { 5537 sv = *v 5538 } 5539 5540 for key, value := range shape { 5541 switch key { 5542 case "accountId": 5543 if value != nil { 5544 jtv, ok := value.(string) 5545 if !ok { 5546 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5547 } 5548 sv.AccountId = ptr.String(jtv) 5549 } 5550 5551 case "administratorAccountId": 5552 if value != nil { 5553 jtv, ok := value.(string) 5554 if !ok { 5555 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5556 } 5557 sv.AdministratorAccountId = ptr.String(jtv) 5558 } 5559 5560 case "arn": 5561 if value != nil { 5562 jtv, ok := value.(string) 5563 if !ok { 5564 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5565 } 5566 sv.Arn = ptr.String(jtv) 5567 } 5568 5569 case "email": 5570 if value != nil { 5571 jtv, ok := value.(string) 5572 if !ok { 5573 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5574 } 5575 sv.Email = ptr.String(jtv) 5576 } 5577 5578 case "invitedAt": 5579 if value != nil { 5580 jtv, ok := value.(string) 5581 if !ok { 5582 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 5583 } 5584 t, err := smithytime.ParseDateTime(jtv) 5585 if err != nil { 5586 return err 5587 } 5588 sv.InvitedAt = ptr.Time(t) 5589 } 5590 5591 case "masterAccountId": 5592 if value != nil { 5593 jtv, ok := value.(string) 5594 if !ok { 5595 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5596 } 5597 sv.MasterAccountId = ptr.String(jtv) 5598 } 5599 5600 case "relationshipStatus": 5601 if value != nil { 5602 jtv, ok := value.(string) 5603 if !ok { 5604 return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value) 5605 } 5606 sv.RelationshipStatus = types.RelationshipStatus(jtv) 5607 } 5608 5609 case "tags": 5610 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 5611 return err 5612 } 5613 5614 case "updatedAt": 5615 if value != nil { 5616 jtv, ok := value.(string) 5617 if !ok { 5618 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 5619 } 5620 t, err := smithytime.ParseDateTime(jtv) 5621 if err != nil { 5622 return err 5623 } 5624 sv.UpdatedAt = ptr.Time(t) 5625 } 5626 5627 default: 5628 _, _ = key, value 5629 5630 } 5631 } 5632 *v = sv 5633 return nil 5634} 5635 5636type awsRestjson1_deserializeOpGetUsageStatistics struct { 5637} 5638 5639func (*awsRestjson1_deserializeOpGetUsageStatistics) ID() string { 5640 return "OperationDeserializer" 5641} 5642 5643func (m *awsRestjson1_deserializeOpGetUsageStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5644 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5645) { 5646 out, metadata, err = next.HandleDeserialize(ctx, in) 5647 if err != nil { 5648 return out, metadata, err 5649 } 5650 5651 response, ok := out.RawResponse.(*smithyhttp.Response) 5652 if !ok { 5653 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5654 } 5655 5656 if response.StatusCode < 200 || response.StatusCode >= 300 { 5657 return out, metadata, awsRestjson1_deserializeOpErrorGetUsageStatistics(response, &metadata) 5658 } 5659 output := &GetUsageStatisticsOutput{} 5660 out.Result = output 5661 5662 var buff [1024]byte 5663 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5664 5665 body := io.TeeReader(response.Body, ringBuffer) 5666 5667 decoder := json.NewDecoder(body) 5668 decoder.UseNumber() 5669 var shape interface{} 5670 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5671 var snapshot bytes.Buffer 5672 io.Copy(&snapshot, ringBuffer) 5673 err = &smithy.DeserializationError{ 5674 Err: fmt.Errorf("failed to decode response body, %w", err), 5675 Snapshot: snapshot.Bytes(), 5676 } 5677 return out, metadata, err 5678 } 5679 5680 err = awsRestjson1_deserializeOpDocumentGetUsageStatisticsOutput(&output, shape) 5681 if err != nil { 5682 var snapshot bytes.Buffer 5683 io.Copy(&snapshot, ringBuffer) 5684 return out, metadata, &smithy.DeserializationError{ 5685 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5686 Snapshot: snapshot.Bytes(), 5687 } 5688 } 5689 5690 return out, metadata, err 5691} 5692 5693func awsRestjson1_deserializeOpErrorGetUsageStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5694 var errorBuffer bytes.Buffer 5695 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5696 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5697 } 5698 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5699 5700 errorCode := "UnknownError" 5701 errorMessage := errorCode 5702 5703 code := response.Header.Get("X-Amzn-ErrorType") 5704 if len(code) != 0 { 5705 errorCode = restjson.SanitizeErrorCode(code) 5706 } 5707 5708 var buff [1024]byte 5709 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5710 5711 body := io.TeeReader(errorBody, ringBuffer) 5712 decoder := json.NewDecoder(body) 5713 decoder.UseNumber() 5714 code, message, err := restjson.GetErrorInfo(decoder) 5715 if err != nil { 5716 var snapshot bytes.Buffer 5717 io.Copy(&snapshot, ringBuffer) 5718 err = &smithy.DeserializationError{ 5719 Err: fmt.Errorf("failed to decode response body, %w", err), 5720 Snapshot: snapshot.Bytes(), 5721 } 5722 return err 5723 } 5724 5725 errorBody.Seek(0, io.SeekStart) 5726 if len(code) != 0 { 5727 errorCode = restjson.SanitizeErrorCode(code) 5728 } 5729 if len(message) != 0 { 5730 errorMessage = message 5731 } 5732 5733 switch { 5734 case strings.EqualFold("AccessDeniedException", errorCode): 5735 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5736 5737 case strings.EqualFold("ConflictException", errorCode): 5738 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5739 5740 case strings.EqualFold("InternalServerException", errorCode): 5741 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5742 5743 case strings.EqualFold("ResourceNotFoundException", errorCode): 5744 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5745 5746 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5747 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5748 5749 case strings.EqualFold("ThrottlingException", errorCode): 5750 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5751 5752 case strings.EqualFold("ValidationException", errorCode): 5753 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5754 5755 default: 5756 genericError := &smithy.GenericAPIError{ 5757 Code: errorCode, 5758 Message: errorMessage, 5759 } 5760 return genericError 5761 5762 } 5763} 5764 5765func awsRestjson1_deserializeOpDocumentGetUsageStatisticsOutput(v **GetUsageStatisticsOutput, value interface{}) error { 5766 if v == nil { 5767 return fmt.Errorf("unexpected nil of type %T", v) 5768 } 5769 if value == nil { 5770 return nil 5771 } 5772 5773 shape, ok := value.(map[string]interface{}) 5774 if !ok { 5775 return fmt.Errorf("unexpected JSON type %v", value) 5776 } 5777 5778 var sv *GetUsageStatisticsOutput 5779 if *v == nil { 5780 sv = &GetUsageStatisticsOutput{} 5781 } else { 5782 sv = *v 5783 } 5784 5785 for key, value := range shape { 5786 switch key { 5787 case "nextToken": 5788 if value != nil { 5789 jtv, ok := value.(string) 5790 if !ok { 5791 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5792 } 5793 sv.NextToken = ptr.String(jtv) 5794 } 5795 5796 case "records": 5797 if err := awsRestjson1_deserializeDocument__listOfUsageRecord(&sv.Records, value); err != nil { 5798 return err 5799 } 5800 5801 case "timeRange": 5802 if value != nil { 5803 jtv, ok := value.(string) 5804 if !ok { 5805 return fmt.Errorf("expected TimeRange to be of type string, got %T instead", value) 5806 } 5807 sv.TimeRange = types.TimeRange(jtv) 5808 } 5809 5810 default: 5811 _, _ = key, value 5812 5813 } 5814 } 5815 *v = sv 5816 return nil 5817} 5818 5819type awsRestjson1_deserializeOpGetUsageTotals struct { 5820} 5821 5822func (*awsRestjson1_deserializeOpGetUsageTotals) ID() string { 5823 return "OperationDeserializer" 5824} 5825 5826func (m *awsRestjson1_deserializeOpGetUsageTotals) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5827 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5828) { 5829 out, metadata, err = next.HandleDeserialize(ctx, in) 5830 if err != nil { 5831 return out, metadata, err 5832 } 5833 5834 response, ok := out.RawResponse.(*smithyhttp.Response) 5835 if !ok { 5836 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5837 } 5838 5839 if response.StatusCode < 200 || response.StatusCode >= 300 { 5840 return out, metadata, awsRestjson1_deserializeOpErrorGetUsageTotals(response, &metadata) 5841 } 5842 output := &GetUsageTotalsOutput{} 5843 out.Result = output 5844 5845 var buff [1024]byte 5846 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5847 5848 body := io.TeeReader(response.Body, ringBuffer) 5849 5850 decoder := json.NewDecoder(body) 5851 decoder.UseNumber() 5852 var shape interface{} 5853 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5854 var snapshot bytes.Buffer 5855 io.Copy(&snapshot, ringBuffer) 5856 err = &smithy.DeserializationError{ 5857 Err: fmt.Errorf("failed to decode response body, %w", err), 5858 Snapshot: snapshot.Bytes(), 5859 } 5860 return out, metadata, err 5861 } 5862 5863 err = awsRestjson1_deserializeOpDocumentGetUsageTotalsOutput(&output, shape) 5864 if err != nil { 5865 var snapshot bytes.Buffer 5866 io.Copy(&snapshot, ringBuffer) 5867 return out, metadata, &smithy.DeserializationError{ 5868 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5869 Snapshot: snapshot.Bytes(), 5870 } 5871 } 5872 5873 return out, metadata, err 5874} 5875 5876func awsRestjson1_deserializeOpErrorGetUsageTotals(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5877 var errorBuffer bytes.Buffer 5878 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5879 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5880 } 5881 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5882 5883 errorCode := "UnknownError" 5884 errorMessage := errorCode 5885 5886 code := response.Header.Get("X-Amzn-ErrorType") 5887 if len(code) != 0 { 5888 errorCode = restjson.SanitizeErrorCode(code) 5889 } 5890 5891 var buff [1024]byte 5892 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5893 5894 body := io.TeeReader(errorBody, ringBuffer) 5895 decoder := json.NewDecoder(body) 5896 decoder.UseNumber() 5897 code, message, err := restjson.GetErrorInfo(decoder) 5898 if err != nil { 5899 var snapshot bytes.Buffer 5900 io.Copy(&snapshot, ringBuffer) 5901 err = &smithy.DeserializationError{ 5902 Err: fmt.Errorf("failed to decode response body, %w", err), 5903 Snapshot: snapshot.Bytes(), 5904 } 5905 return err 5906 } 5907 5908 errorBody.Seek(0, io.SeekStart) 5909 if len(code) != 0 { 5910 errorCode = restjson.SanitizeErrorCode(code) 5911 } 5912 if len(message) != 0 { 5913 errorMessage = message 5914 } 5915 5916 switch { 5917 case strings.EqualFold("AccessDeniedException", errorCode): 5918 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5919 5920 case strings.EqualFold("ConflictException", errorCode): 5921 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5922 5923 case strings.EqualFold("InternalServerException", errorCode): 5924 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 5925 5926 case strings.EqualFold("ResourceNotFoundException", errorCode): 5927 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5928 5929 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 5930 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 5931 5932 case strings.EqualFold("ThrottlingException", errorCode): 5933 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 5934 5935 case strings.EqualFold("ValidationException", errorCode): 5936 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5937 5938 default: 5939 genericError := &smithy.GenericAPIError{ 5940 Code: errorCode, 5941 Message: errorMessage, 5942 } 5943 return genericError 5944 5945 } 5946} 5947 5948func awsRestjson1_deserializeOpDocumentGetUsageTotalsOutput(v **GetUsageTotalsOutput, value interface{}) error { 5949 if v == nil { 5950 return fmt.Errorf("unexpected nil of type %T", v) 5951 } 5952 if value == nil { 5953 return nil 5954 } 5955 5956 shape, ok := value.(map[string]interface{}) 5957 if !ok { 5958 return fmt.Errorf("unexpected JSON type %v", value) 5959 } 5960 5961 var sv *GetUsageTotalsOutput 5962 if *v == nil { 5963 sv = &GetUsageTotalsOutput{} 5964 } else { 5965 sv = *v 5966 } 5967 5968 for key, value := range shape { 5969 switch key { 5970 case "timeRange": 5971 if value != nil { 5972 jtv, ok := value.(string) 5973 if !ok { 5974 return fmt.Errorf("expected TimeRange to be of type string, got %T instead", value) 5975 } 5976 sv.TimeRange = types.TimeRange(jtv) 5977 } 5978 5979 case "usageTotals": 5980 if err := awsRestjson1_deserializeDocument__listOfUsageTotal(&sv.UsageTotals, value); err != nil { 5981 return err 5982 } 5983 5984 default: 5985 _, _ = key, value 5986 5987 } 5988 } 5989 *v = sv 5990 return nil 5991} 5992 5993type awsRestjson1_deserializeOpListClassificationJobs struct { 5994} 5995 5996func (*awsRestjson1_deserializeOpListClassificationJobs) ID() string { 5997 return "OperationDeserializer" 5998} 5999 6000func (m *awsRestjson1_deserializeOpListClassificationJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6001 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6002) { 6003 out, metadata, err = next.HandleDeserialize(ctx, in) 6004 if err != nil { 6005 return out, metadata, err 6006 } 6007 6008 response, ok := out.RawResponse.(*smithyhttp.Response) 6009 if !ok { 6010 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6011 } 6012 6013 if response.StatusCode < 200 || response.StatusCode >= 300 { 6014 return out, metadata, awsRestjson1_deserializeOpErrorListClassificationJobs(response, &metadata) 6015 } 6016 output := &ListClassificationJobsOutput{} 6017 out.Result = output 6018 6019 var buff [1024]byte 6020 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6021 6022 body := io.TeeReader(response.Body, ringBuffer) 6023 6024 decoder := json.NewDecoder(body) 6025 decoder.UseNumber() 6026 var shape interface{} 6027 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6028 var snapshot bytes.Buffer 6029 io.Copy(&snapshot, ringBuffer) 6030 err = &smithy.DeserializationError{ 6031 Err: fmt.Errorf("failed to decode response body, %w", err), 6032 Snapshot: snapshot.Bytes(), 6033 } 6034 return out, metadata, err 6035 } 6036 6037 err = awsRestjson1_deserializeOpDocumentListClassificationJobsOutput(&output, shape) 6038 if err != nil { 6039 var snapshot bytes.Buffer 6040 io.Copy(&snapshot, ringBuffer) 6041 return out, metadata, &smithy.DeserializationError{ 6042 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6043 Snapshot: snapshot.Bytes(), 6044 } 6045 } 6046 6047 return out, metadata, err 6048} 6049 6050func awsRestjson1_deserializeOpErrorListClassificationJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6051 var errorBuffer bytes.Buffer 6052 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6053 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6054 } 6055 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6056 6057 errorCode := "UnknownError" 6058 errorMessage := errorCode 6059 6060 code := response.Header.Get("X-Amzn-ErrorType") 6061 if len(code) != 0 { 6062 errorCode = restjson.SanitizeErrorCode(code) 6063 } 6064 6065 var buff [1024]byte 6066 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6067 6068 body := io.TeeReader(errorBody, ringBuffer) 6069 decoder := json.NewDecoder(body) 6070 decoder.UseNumber() 6071 code, message, err := restjson.GetErrorInfo(decoder) 6072 if err != nil { 6073 var snapshot bytes.Buffer 6074 io.Copy(&snapshot, ringBuffer) 6075 err = &smithy.DeserializationError{ 6076 Err: fmt.Errorf("failed to decode response body, %w", err), 6077 Snapshot: snapshot.Bytes(), 6078 } 6079 return err 6080 } 6081 6082 errorBody.Seek(0, io.SeekStart) 6083 if len(code) != 0 { 6084 errorCode = restjson.SanitizeErrorCode(code) 6085 } 6086 if len(message) != 0 { 6087 errorMessage = message 6088 } 6089 6090 switch { 6091 case strings.EqualFold("AccessDeniedException", errorCode): 6092 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6093 6094 case strings.EqualFold("ConflictException", errorCode): 6095 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6096 6097 case strings.EqualFold("InternalServerException", errorCode): 6098 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6099 6100 case strings.EqualFold("ResourceNotFoundException", errorCode): 6101 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6102 6103 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6104 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6105 6106 case strings.EqualFold("ThrottlingException", errorCode): 6107 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6108 6109 case strings.EqualFold("ValidationException", errorCode): 6110 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6111 6112 default: 6113 genericError := &smithy.GenericAPIError{ 6114 Code: errorCode, 6115 Message: errorMessage, 6116 } 6117 return genericError 6118 6119 } 6120} 6121 6122func awsRestjson1_deserializeOpDocumentListClassificationJobsOutput(v **ListClassificationJobsOutput, value interface{}) error { 6123 if v == nil { 6124 return fmt.Errorf("unexpected nil of type %T", v) 6125 } 6126 if value == nil { 6127 return nil 6128 } 6129 6130 shape, ok := value.(map[string]interface{}) 6131 if !ok { 6132 return fmt.Errorf("unexpected JSON type %v", value) 6133 } 6134 6135 var sv *ListClassificationJobsOutput 6136 if *v == nil { 6137 sv = &ListClassificationJobsOutput{} 6138 } else { 6139 sv = *v 6140 } 6141 6142 for key, value := range shape { 6143 switch key { 6144 case "items": 6145 if err := awsRestjson1_deserializeDocument__listOfJobSummary(&sv.Items, value); err != nil { 6146 return err 6147 } 6148 6149 case "nextToken": 6150 if value != nil { 6151 jtv, ok := value.(string) 6152 if !ok { 6153 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6154 } 6155 sv.NextToken = ptr.String(jtv) 6156 } 6157 6158 default: 6159 _, _ = key, value 6160 6161 } 6162 } 6163 *v = sv 6164 return nil 6165} 6166 6167type awsRestjson1_deserializeOpListCustomDataIdentifiers struct { 6168} 6169 6170func (*awsRestjson1_deserializeOpListCustomDataIdentifiers) ID() string { 6171 return "OperationDeserializer" 6172} 6173 6174func (m *awsRestjson1_deserializeOpListCustomDataIdentifiers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6175 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6176) { 6177 out, metadata, err = next.HandleDeserialize(ctx, in) 6178 if err != nil { 6179 return out, metadata, err 6180 } 6181 6182 response, ok := out.RawResponse.(*smithyhttp.Response) 6183 if !ok { 6184 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6185 } 6186 6187 if response.StatusCode < 200 || response.StatusCode >= 300 { 6188 return out, metadata, awsRestjson1_deserializeOpErrorListCustomDataIdentifiers(response, &metadata) 6189 } 6190 output := &ListCustomDataIdentifiersOutput{} 6191 out.Result = output 6192 6193 var buff [1024]byte 6194 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6195 6196 body := io.TeeReader(response.Body, ringBuffer) 6197 6198 decoder := json.NewDecoder(body) 6199 decoder.UseNumber() 6200 var shape interface{} 6201 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6202 var snapshot bytes.Buffer 6203 io.Copy(&snapshot, ringBuffer) 6204 err = &smithy.DeserializationError{ 6205 Err: fmt.Errorf("failed to decode response body, %w", err), 6206 Snapshot: snapshot.Bytes(), 6207 } 6208 return out, metadata, err 6209 } 6210 6211 err = awsRestjson1_deserializeOpDocumentListCustomDataIdentifiersOutput(&output, shape) 6212 if err != nil { 6213 var snapshot bytes.Buffer 6214 io.Copy(&snapshot, ringBuffer) 6215 return out, metadata, &smithy.DeserializationError{ 6216 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6217 Snapshot: snapshot.Bytes(), 6218 } 6219 } 6220 6221 return out, metadata, err 6222} 6223 6224func awsRestjson1_deserializeOpErrorListCustomDataIdentifiers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6225 var errorBuffer bytes.Buffer 6226 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6227 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6228 } 6229 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6230 6231 errorCode := "UnknownError" 6232 errorMessage := errorCode 6233 6234 code := response.Header.Get("X-Amzn-ErrorType") 6235 if len(code) != 0 { 6236 errorCode = restjson.SanitizeErrorCode(code) 6237 } 6238 6239 var buff [1024]byte 6240 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6241 6242 body := io.TeeReader(errorBody, ringBuffer) 6243 decoder := json.NewDecoder(body) 6244 decoder.UseNumber() 6245 code, message, err := restjson.GetErrorInfo(decoder) 6246 if err != nil { 6247 var snapshot bytes.Buffer 6248 io.Copy(&snapshot, ringBuffer) 6249 err = &smithy.DeserializationError{ 6250 Err: fmt.Errorf("failed to decode response body, %w", err), 6251 Snapshot: snapshot.Bytes(), 6252 } 6253 return err 6254 } 6255 6256 errorBody.Seek(0, io.SeekStart) 6257 if len(code) != 0 { 6258 errorCode = restjson.SanitizeErrorCode(code) 6259 } 6260 if len(message) != 0 { 6261 errorMessage = message 6262 } 6263 6264 switch { 6265 case strings.EqualFold("AccessDeniedException", errorCode): 6266 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6267 6268 case strings.EqualFold("ConflictException", errorCode): 6269 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6270 6271 case strings.EqualFold("InternalServerException", errorCode): 6272 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6273 6274 case strings.EqualFold("ResourceNotFoundException", errorCode): 6275 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6276 6277 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6278 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6279 6280 case strings.EqualFold("ThrottlingException", errorCode): 6281 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6282 6283 case strings.EqualFold("ValidationException", errorCode): 6284 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6285 6286 default: 6287 genericError := &smithy.GenericAPIError{ 6288 Code: errorCode, 6289 Message: errorMessage, 6290 } 6291 return genericError 6292 6293 } 6294} 6295 6296func awsRestjson1_deserializeOpDocumentListCustomDataIdentifiersOutput(v **ListCustomDataIdentifiersOutput, value interface{}) error { 6297 if v == nil { 6298 return fmt.Errorf("unexpected nil of type %T", v) 6299 } 6300 if value == nil { 6301 return nil 6302 } 6303 6304 shape, ok := value.(map[string]interface{}) 6305 if !ok { 6306 return fmt.Errorf("unexpected JSON type %v", value) 6307 } 6308 6309 var sv *ListCustomDataIdentifiersOutput 6310 if *v == nil { 6311 sv = &ListCustomDataIdentifiersOutput{} 6312 } else { 6313 sv = *v 6314 } 6315 6316 for key, value := range shape { 6317 switch key { 6318 case "items": 6319 if err := awsRestjson1_deserializeDocument__listOfCustomDataIdentifierSummary(&sv.Items, value); err != nil { 6320 return err 6321 } 6322 6323 case "nextToken": 6324 if value != nil { 6325 jtv, ok := value.(string) 6326 if !ok { 6327 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6328 } 6329 sv.NextToken = ptr.String(jtv) 6330 } 6331 6332 default: 6333 _, _ = key, value 6334 6335 } 6336 } 6337 *v = sv 6338 return nil 6339} 6340 6341type awsRestjson1_deserializeOpListFindings struct { 6342} 6343 6344func (*awsRestjson1_deserializeOpListFindings) ID() string { 6345 return "OperationDeserializer" 6346} 6347 6348func (m *awsRestjson1_deserializeOpListFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6349 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6350) { 6351 out, metadata, err = next.HandleDeserialize(ctx, in) 6352 if err != nil { 6353 return out, metadata, err 6354 } 6355 6356 response, ok := out.RawResponse.(*smithyhttp.Response) 6357 if !ok { 6358 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6359 } 6360 6361 if response.StatusCode < 200 || response.StatusCode >= 300 { 6362 return out, metadata, awsRestjson1_deserializeOpErrorListFindings(response, &metadata) 6363 } 6364 output := &ListFindingsOutput{} 6365 out.Result = output 6366 6367 var buff [1024]byte 6368 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6369 6370 body := io.TeeReader(response.Body, ringBuffer) 6371 6372 decoder := json.NewDecoder(body) 6373 decoder.UseNumber() 6374 var shape interface{} 6375 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6376 var snapshot bytes.Buffer 6377 io.Copy(&snapshot, ringBuffer) 6378 err = &smithy.DeserializationError{ 6379 Err: fmt.Errorf("failed to decode response body, %w", err), 6380 Snapshot: snapshot.Bytes(), 6381 } 6382 return out, metadata, err 6383 } 6384 6385 err = awsRestjson1_deserializeOpDocumentListFindingsOutput(&output, shape) 6386 if err != nil { 6387 var snapshot bytes.Buffer 6388 io.Copy(&snapshot, ringBuffer) 6389 return out, metadata, &smithy.DeserializationError{ 6390 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6391 Snapshot: snapshot.Bytes(), 6392 } 6393 } 6394 6395 return out, metadata, err 6396} 6397 6398func awsRestjson1_deserializeOpErrorListFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6399 var errorBuffer bytes.Buffer 6400 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6401 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6402 } 6403 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6404 6405 errorCode := "UnknownError" 6406 errorMessage := errorCode 6407 6408 code := response.Header.Get("X-Amzn-ErrorType") 6409 if len(code) != 0 { 6410 errorCode = restjson.SanitizeErrorCode(code) 6411 } 6412 6413 var buff [1024]byte 6414 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6415 6416 body := io.TeeReader(errorBody, ringBuffer) 6417 decoder := json.NewDecoder(body) 6418 decoder.UseNumber() 6419 code, message, err := restjson.GetErrorInfo(decoder) 6420 if err != nil { 6421 var snapshot bytes.Buffer 6422 io.Copy(&snapshot, ringBuffer) 6423 err = &smithy.DeserializationError{ 6424 Err: fmt.Errorf("failed to decode response body, %w", err), 6425 Snapshot: snapshot.Bytes(), 6426 } 6427 return err 6428 } 6429 6430 errorBody.Seek(0, io.SeekStart) 6431 if len(code) != 0 { 6432 errorCode = restjson.SanitizeErrorCode(code) 6433 } 6434 if len(message) != 0 { 6435 errorMessage = message 6436 } 6437 6438 switch { 6439 case strings.EqualFold("AccessDeniedException", errorCode): 6440 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6441 6442 case strings.EqualFold("ConflictException", errorCode): 6443 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6444 6445 case strings.EqualFold("InternalServerException", errorCode): 6446 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6447 6448 case strings.EqualFold("ResourceNotFoundException", errorCode): 6449 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6450 6451 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6452 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6453 6454 case strings.EqualFold("ThrottlingException", errorCode): 6455 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6456 6457 case strings.EqualFold("ValidationException", errorCode): 6458 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6459 6460 default: 6461 genericError := &smithy.GenericAPIError{ 6462 Code: errorCode, 6463 Message: errorMessage, 6464 } 6465 return genericError 6466 6467 } 6468} 6469 6470func awsRestjson1_deserializeOpDocumentListFindingsOutput(v **ListFindingsOutput, value interface{}) error { 6471 if v == nil { 6472 return fmt.Errorf("unexpected nil of type %T", v) 6473 } 6474 if value == nil { 6475 return nil 6476 } 6477 6478 shape, ok := value.(map[string]interface{}) 6479 if !ok { 6480 return fmt.Errorf("unexpected JSON type %v", value) 6481 } 6482 6483 var sv *ListFindingsOutput 6484 if *v == nil { 6485 sv = &ListFindingsOutput{} 6486 } else { 6487 sv = *v 6488 } 6489 6490 for key, value := range shape { 6491 switch key { 6492 case "findingIds": 6493 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.FindingIds, value); err != nil { 6494 return err 6495 } 6496 6497 case "nextToken": 6498 if value != nil { 6499 jtv, ok := value.(string) 6500 if !ok { 6501 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6502 } 6503 sv.NextToken = ptr.String(jtv) 6504 } 6505 6506 default: 6507 _, _ = key, value 6508 6509 } 6510 } 6511 *v = sv 6512 return nil 6513} 6514 6515type awsRestjson1_deserializeOpListFindingsFilters struct { 6516} 6517 6518func (*awsRestjson1_deserializeOpListFindingsFilters) ID() string { 6519 return "OperationDeserializer" 6520} 6521 6522func (m *awsRestjson1_deserializeOpListFindingsFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6523 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6524) { 6525 out, metadata, err = next.HandleDeserialize(ctx, in) 6526 if err != nil { 6527 return out, metadata, err 6528 } 6529 6530 response, ok := out.RawResponse.(*smithyhttp.Response) 6531 if !ok { 6532 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6533 } 6534 6535 if response.StatusCode < 200 || response.StatusCode >= 300 { 6536 return out, metadata, awsRestjson1_deserializeOpErrorListFindingsFilters(response, &metadata) 6537 } 6538 output := &ListFindingsFiltersOutput{} 6539 out.Result = output 6540 6541 var buff [1024]byte 6542 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6543 6544 body := io.TeeReader(response.Body, ringBuffer) 6545 6546 decoder := json.NewDecoder(body) 6547 decoder.UseNumber() 6548 var shape interface{} 6549 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6550 var snapshot bytes.Buffer 6551 io.Copy(&snapshot, ringBuffer) 6552 err = &smithy.DeserializationError{ 6553 Err: fmt.Errorf("failed to decode response body, %w", err), 6554 Snapshot: snapshot.Bytes(), 6555 } 6556 return out, metadata, err 6557 } 6558 6559 err = awsRestjson1_deserializeOpDocumentListFindingsFiltersOutput(&output, shape) 6560 if err != nil { 6561 var snapshot bytes.Buffer 6562 io.Copy(&snapshot, ringBuffer) 6563 return out, metadata, &smithy.DeserializationError{ 6564 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6565 Snapshot: snapshot.Bytes(), 6566 } 6567 } 6568 6569 return out, metadata, err 6570} 6571 6572func awsRestjson1_deserializeOpErrorListFindingsFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6573 var errorBuffer bytes.Buffer 6574 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6575 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6576 } 6577 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6578 6579 errorCode := "UnknownError" 6580 errorMessage := errorCode 6581 6582 code := response.Header.Get("X-Amzn-ErrorType") 6583 if len(code) != 0 { 6584 errorCode = restjson.SanitizeErrorCode(code) 6585 } 6586 6587 var buff [1024]byte 6588 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6589 6590 body := io.TeeReader(errorBody, ringBuffer) 6591 decoder := json.NewDecoder(body) 6592 decoder.UseNumber() 6593 code, message, err := restjson.GetErrorInfo(decoder) 6594 if err != nil { 6595 var snapshot bytes.Buffer 6596 io.Copy(&snapshot, ringBuffer) 6597 err = &smithy.DeserializationError{ 6598 Err: fmt.Errorf("failed to decode response body, %w", err), 6599 Snapshot: snapshot.Bytes(), 6600 } 6601 return err 6602 } 6603 6604 errorBody.Seek(0, io.SeekStart) 6605 if len(code) != 0 { 6606 errorCode = restjson.SanitizeErrorCode(code) 6607 } 6608 if len(message) != 0 { 6609 errorMessage = message 6610 } 6611 6612 switch { 6613 case strings.EqualFold("AccessDeniedException", errorCode): 6614 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6615 6616 case strings.EqualFold("ConflictException", errorCode): 6617 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6618 6619 case strings.EqualFold("InternalServerException", errorCode): 6620 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6621 6622 case strings.EqualFold("ResourceNotFoundException", errorCode): 6623 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6624 6625 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6626 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6627 6628 case strings.EqualFold("ThrottlingException", errorCode): 6629 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6630 6631 case strings.EqualFold("ValidationException", errorCode): 6632 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6633 6634 default: 6635 genericError := &smithy.GenericAPIError{ 6636 Code: errorCode, 6637 Message: errorMessage, 6638 } 6639 return genericError 6640 6641 } 6642} 6643 6644func awsRestjson1_deserializeOpDocumentListFindingsFiltersOutput(v **ListFindingsFiltersOutput, value interface{}) error { 6645 if v == nil { 6646 return fmt.Errorf("unexpected nil of type %T", v) 6647 } 6648 if value == nil { 6649 return nil 6650 } 6651 6652 shape, ok := value.(map[string]interface{}) 6653 if !ok { 6654 return fmt.Errorf("unexpected JSON type %v", value) 6655 } 6656 6657 var sv *ListFindingsFiltersOutput 6658 if *v == nil { 6659 sv = &ListFindingsFiltersOutput{} 6660 } else { 6661 sv = *v 6662 } 6663 6664 for key, value := range shape { 6665 switch key { 6666 case "findingsFilterListItems": 6667 if err := awsRestjson1_deserializeDocument__listOfFindingsFilterListItem(&sv.FindingsFilterListItems, value); err != nil { 6668 return err 6669 } 6670 6671 case "nextToken": 6672 if value != nil { 6673 jtv, ok := value.(string) 6674 if !ok { 6675 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6676 } 6677 sv.NextToken = ptr.String(jtv) 6678 } 6679 6680 default: 6681 _, _ = key, value 6682 6683 } 6684 } 6685 *v = sv 6686 return nil 6687} 6688 6689type awsRestjson1_deserializeOpListInvitations struct { 6690} 6691 6692func (*awsRestjson1_deserializeOpListInvitations) ID() string { 6693 return "OperationDeserializer" 6694} 6695 6696func (m *awsRestjson1_deserializeOpListInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6697 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6698) { 6699 out, metadata, err = next.HandleDeserialize(ctx, in) 6700 if err != nil { 6701 return out, metadata, err 6702 } 6703 6704 response, ok := out.RawResponse.(*smithyhttp.Response) 6705 if !ok { 6706 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6707 } 6708 6709 if response.StatusCode < 200 || response.StatusCode >= 300 { 6710 return out, metadata, awsRestjson1_deserializeOpErrorListInvitations(response, &metadata) 6711 } 6712 output := &ListInvitationsOutput{} 6713 out.Result = output 6714 6715 var buff [1024]byte 6716 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6717 6718 body := io.TeeReader(response.Body, ringBuffer) 6719 6720 decoder := json.NewDecoder(body) 6721 decoder.UseNumber() 6722 var shape interface{} 6723 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6724 var snapshot bytes.Buffer 6725 io.Copy(&snapshot, ringBuffer) 6726 err = &smithy.DeserializationError{ 6727 Err: fmt.Errorf("failed to decode response body, %w", err), 6728 Snapshot: snapshot.Bytes(), 6729 } 6730 return out, metadata, err 6731 } 6732 6733 err = awsRestjson1_deserializeOpDocumentListInvitationsOutput(&output, shape) 6734 if err != nil { 6735 var snapshot bytes.Buffer 6736 io.Copy(&snapshot, ringBuffer) 6737 return out, metadata, &smithy.DeserializationError{ 6738 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6739 Snapshot: snapshot.Bytes(), 6740 } 6741 } 6742 6743 return out, metadata, err 6744} 6745 6746func awsRestjson1_deserializeOpErrorListInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6747 var errorBuffer bytes.Buffer 6748 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6749 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6750 } 6751 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6752 6753 errorCode := "UnknownError" 6754 errorMessage := errorCode 6755 6756 code := response.Header.Get("X-Amzn-ErrorType") 6757 if len(code) != 0 { 6758 errorCode = restjson.SanitizeErrorCode(code) 6759 } 6760 6761 var buff [1024]byte 6762 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6763 6764 body := io.TeeReader(errorBody, ringBuffer) 6765 decoder := json.NewDecoder(body) 6766 decoder.UseNumber() 6767 code, message, err := restjson.GetErrorInfo(decoder) 6768 if err != nil { 6769 var snapshot bytes.Buffer 6770 io.Copy(&snapshot, ringBuffer) 6771 err = &smithy.DeserializationError{ 6772 Err: fmt.Errorf("failed to decode response body, %w", err), 6773 Snapshot: snapshot.Bytes(), 6774 } 6775 return err 6776 } 6777 6778 errorBody.Seek(0, io.SeekStart) 6779 if len(code) != 0 { 6780 errorCode = restjson.SanitizeErrorCode(code) 6781 } 6782 if len(message) != 0 { 6783 errorMessage = message 6784 } 6785 6786 switch { 6787 case strings.EqualFold("AccessDeniedException", errorCode): 6788 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6789 6790 case strings.EqualFold("ConflictException", errorCode): 6791 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6792 6793 case strings.EqualFold("InternalServerException", errorCode): 6794 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6795 6796 case strings.EqualFold("ResourceNotFoundException", errorCode): 6797 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6798 6799 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6800 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6801 6802 case strings.EqualFold("ThrottlingException", errorCode): 6803 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6804 6805 case strings.EqualFold("ValidationException", errorCode): 6806 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6807 6808 default: 6809 genericError := &smithy.GenericAPIError{ 6810 Code: errorCode, 6811 Message: errorMessage, 6812 } 6813 return genericError 6814 6815 } 6816} 6817 6818func awsRestjson1_deserializeOpDocumentListInvitationsOutput(v **ListInvitationsOutput, value interface{}) error { 6819 if v == nil { 6820 return fmt.Errorf("unexpected nil of type %T", v) 6821 } 6822 if value == nil { 6823 return nil 6824 } 6825 6826 shape, ok := value.(map[string]interface{}) 6827 if !ok { 6828 return fmt.Errorf("unexpected JSON type %v", value) 6829 } 6830 6831 var sv *ListInvitationsOutput 6832 if *v == nil { 6833 sv = &ListInvitationsOutput{} 6834 } else { 6835 sv = *v 6836 } 6837 6838 for key, value := range shape { 6839 switch key { 6840 case "invitations": 6841 if err := awsRestjson1_deserializeDocument__listOfInvitation(&sv.Invitations, value); err != nil { 6842 return err 6843 } 6844 6845 case "nextToken": 6846 if value != nil { 6847 jtv, ok := value.(string) 6848 if !ok { 6849 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6850 } 6851 sv.NextToken = ptr.String(jtv) 6852 } 6853 6854 default: 6855 _, _ = key, value 6856 6857 } 6858 } 6859 *v = sv 6860 return nil 6861} 6862 6863type awsRestjson1_deserializeOpListMembers struct { 6864} 6865 6866func (*awsRestjson1_deserializeOpListMembers) ID() string { 6867 return "OperationDeserializer" 6868} 6869 6870func (m *awsRestjson1_deserializeOpListMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6871 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6872) { 6873 out, metadata, err = next.HandleDeserialize(ctx, in) 6874 if err != nil { 6875 return out, metadata, err 6876 } 6877 6878 response, ok := out.RawResponse.(*smithyhttp.Response) 6879 if !ok { 6880 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6881 } 6882 6883 if response.StatusCode < 200 || response.StatusCode >= 300 { 6884 return out, metadata, awsRestjson1_deserializeOpErrorListMembers(response, &metadata) 6885 } 6886 output := &ListMembersOutput{} 6887 out.Result = output 6888 6889 var buff [1024]byte 6890 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6891 6892 body := io.TeeReader(response.Body, ringBuffer) 6893 6894 decoder := json.NewDecoder(body) 6895 decoder.UseNumber() 6896 var shape interface{} 6897 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6898 var snapshot bytes.Buffer 6899 io.Copy(&snapshot, ringBuffer) 6900 err = &smithy.DeserializationError{ 6901 Err: fmt.Errorf("failed to decode response body, %w", err), 6902 Snapshot: snapshot.Bytes(), 6903 } 6904 return out, metadata, err 6905 } 6906 6907 err = awsRestjson1_deserializeOpDocumentListMembersOutput(&output, shape) 6908 if err != nil { 6909 var snapshot bytes.Buffer 6910 io.Copy(&snapshot, ringBuffer) 6911 return out, metadata, &smithy.DeserializationError{ 6912 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6913 Snapshot: snapshot.Bytes(), 6914 } 6915 } 6916 6917 return out, metadata, err 6918} 6919 6920func awsRestjson1_deserializeOpErrorListMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6921 var errorBuffer bytes.Buffer 6922 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6923 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6924 } 6925 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6926 6927 errorCode := "UnknownError" 6928 errorMessage := errorCode 6929 6930 code := response.Header.Get("X-Amzn-ErrorType") 6931 if len(code) != 0 { 6932 errorCode = restjson.SanitizeErrorCode(code) 6933 } 6934 6935 var buff [1024]byte 6936 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6937 6938 body := io.TeeReader(errorBody, ringBuffer) 6939 decoder := json.NewDecoder(body) 6940 decoder.UseNumber() 6941 code, message, err := restjson.GetErrorInfo(decoder) 6942 if err != nil { 6943 var snapshot bytes.Buffer 6944 io.Copy(&snapshot, ringBuffer) 6945 err = &smithy.DeserializationError{ 6946 Err: fmt.Errorf("failed to decode response body, %w", err), 6947 Snapshot: snapshot.Bytes(), 6948 } 6949 return err 6950 } 6951 6952 errorBody.Seek(0, io.SeekStart) 6953 if len(code) != 0 { 6954 errorCode = restjson.SanitizeErrorCode(code) 6955 } 6956 if len(message) != 0 { 6957 errorMessage = message 6958 } 6959 6960 switch { 6961 case strings.EqualFold("AccessDeniedException", errorCode): 6962 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6963 6964 case strings.EqualFold("ConflictException", errorCode): 6965 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6966 6967 case strings.EqualFold("InternalServerException", errorCode): 6968 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 6969 6970 case strings.EqualFold("ResourceNotFoundException", errorCode): 6971 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6972 6973 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 6974 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 6975 6976 case strings.EqualFold("ThrottlingException", errorCode): 6977 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 6978 6979 case strings.EqualFold("ValidationException", errorCode): 6980 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6981 6982 default: 6983 genericError := &smithy.GenericAPIError{ 6984 Code: errorCode, 6985 Message: errorMessage, 6986 } 6987 return genericError 6988 6989 } 6990} 6991 6992func awsRestjson1_deserializeOpDocumentListMembersOutput(v **ListMembersOutput, value interface{}) error { 6993 if v == nil { 6994 return fmt.Errorf("unexpected nil of type %T", v) 6995 } 6996 if value == nil { 6997 return nil 6998 } 6999 7000 shape, ok := value.(map[string]interface{}) 7001 if !ok { 7002 return fmt.Errorf("unexpected JSON type %v", value) 7003 } 7004 7005 var sv *ListMembersOutput 7006 if *v == nil { 7007 sv = &ListMembersOutput{} 7008 } else { 7009 sv = *v 7010 } 7011 7012 for key, value := range shape { 7013 switch key { 7014 case "members": 7015 if err := awsRestjson1_deserializeDocument__listOfMember(&sv.Members, value); err != nil { 7016 return err 7017 } 7018 7019 case "nextToken": 7020 if value != nil { 7021 jtv, ok := value.(string) 7022 if !ok { 7023 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7024 } 7025 sv.NextToken = ptr.String(jtv) 7026 } 7027 7028 default: 7029 _, _ = key, value 7030 7031 } 7032 } 7033 *v = sv 7034 return nil 7035} 7036 7037type awsRestjson1_deserializeOpListOrganizationAdminAccounts struct { 7038} 7039 7040func (*awsRestjson1_deserializeOpListOrganizationAdminAccounts) ID() string { 7041 return "OperationDeserializer" 7042} 7043 7044func (m *awsRestjson1_deserializeOpListOrganizationAdminAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7045 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7046) { 7047 out, metadata, err = next.HandleDeserialize(ctx, in) 7048 if err != nil { 7049 return out, metadata, err 7050 } 7051 7052 response, ok := out.RawResponse.(*smithyhttp.Response) 7053 if !ok { 7054 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7055 } 7056 7057 if response.StatusCode < 200 || response.StatusCode >= 300 { 7058 return out, metadata, awsRestjson1_deserializeOpErrorListOrganizationAdminAccounts(response, &metadata) 7059 } 7060 output := &ListOrganizationAdminAccountsOutput{} 7061 out.Result = output 7062 7063 var buff [1024]byte 7064 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7065 7066 body := io.TeeReader(response.Body, ringBuffer) 7067 7068 decoder := json.NewDecoder(body) 7069 decoder.UseNumber() 7070 var shape interface{} 7071 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7072 var snapshot bytes.Buffer 7073 io.Copy(&snapshot, ringBuffer) 7074 err = &smithy.DeserializationError{ 7075 Err: fmt.Errorf("failed to decode response body, %w", err), 7076 Snapshot: snapshot.Bytes(), 7077 } 7078 return out, metadata, err 7079 } 7080 7081 err = awsRestjson1_deserializeOpDocumentListOrganizationAdminAccountsOutput(&output, shape) 7082 if err != nil { 7083 var snapshot bytes.Buffer 7084 io.Copy(&snapshot, ringBuffer) 7085 return out, metadata, &smithy.DeserializationError{ 7086 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7087 Snapshot: snapshot.Bytes(), 7088 } 7089 } 7090 7091 return out, metadata, err 7092} 7093 7094func awsRestjson1_deserializeOpErrorListOrganizationAdminAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7095 var errorBuffer bytes.Buffer 7096 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7097 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7098 } 7099 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7100 7101 errorCode := "UnknownError" 7102 errorMessage := errorCode 7103 7104 code := response.Header.Get("X-Amzn-ErrorType") 7105 if len(code) != 0 { 7106 errorCode = restjson.SanitizeErrorCode(code) 7107 } 7108 7109 var buff [1024]byte 7110 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7111 7112 body := io.TeeReader(errorBody, ringBuffer) 7113 decoder := json.NewDecoder(body) 7114 decoder.UseNumber() 7115 code, message, err := restjson.GetErrorInfo(decoder) 7116 if err != nil { 7117 var snapshot bytes.Buffer 7118 io.Copy(&snapshot, ringBuffer) 7119 err = &smithy.DeserializationError{ 7120 Err: fmt.Errorf("failed to decode response body, %w", err), 7121 Snapshot: snapshot.Bytes(), 7122 } 7123 return err 7124 } 7125 7126 errorBody.Seek(0, io.SeekStart) 7127 if len(code) != 0 { 7128 errorCode = restjson.SanitizeErrorCode(code) 7129 } 7130 if len(message) != 0 { 7131 errorMessage = message 7132 } 7133 7134 switch { 7135 case strings.EqualFold("AccessDeniedException", errorCode): 7136 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7137 7138 case strings.EqualFold("ConflictException", errorCode): 7139 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7140 7141 case strings.EqualFold("InternalServerException", errorCode): 7142 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7143 7144 case strings.EqualFold("ResourceNotFoundException", errorCode): 7145 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7146 7147 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7148 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7149 7150 case strings.EqualFold("ThrottlingException", errorCode): 7151 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7152 7153 case strings.EqualFold("ValidationException", errorCode): 7154 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7155 7156 default: 7157 genericError := &smithy.GenericAPIError{ 7158 Code: errorCode, 7159 Message: errorMessage, 7160 } 7161 return genericError 7162 7163 } 7164} 7165 7166func awsRestjson1_deserializeOpDocumentListOrganizationAdminAccountsOutput(v **ListOrganizationAdminAccountsOutput, value interface{}) error { 7167 if v == nil { 7168 return fmt.Errorf("unexpected nil of type %T", v) 7169 } 7170 if value == nil { 7171 return nil 7172 } 7173 7174 shape, ok := value.(map[string]interface{}) 7175 if !ok { 7176 return fmt.Errorf("unexpected JSON type %v", value) 7177 } 7178 7179 var sv *ListOrganizationAdminAccountsOutput 7180 if *v == nil { 7181 sv = &ListOrganizationAdminAccountsOutput{} 7182 } else { 7183 sv = *v 7184 } 7185 7186 for key, value := range shape { 7187 switch key { 7188 case "adminAccounts": 7189 if err := awsRestjson1_deserializeDocument__listOfAdminAccount(&sv.AdminAccounts, value); err != nil { 7190 return err 7191 } 7192 7193 case "nextToken": 7194 if value != nil { 7195 jtv, ok := value.(string) 7196 if !ok { 7197 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7198 } 7199 sv.NextToken = ptr.String(jtv) 7200 } 7201 7202 default: 7203 _, _ = key, value 7204 7205 } 7206 } 7207 *v = sv 7208 return nil 7209} 7210 7211type awsRestjson1_deserializeOpListTagsForResource struct { 7212} 7213 7214func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 7215 return "OperationDeserializer" 7216} 7217 7218func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7219 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7220) { 7221 out, metadata, err = next.HandleDeserialize(ctx, in) 7222 if err != nil { 7223 return out, metadata, err 7224 } 7225 7226 response, ok := out.RawResponse.(*smithyhttp.Response) 7227 if !ok { 7228 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7229 } 7230 7231 if response.StatusCode < 200 || response.StatusCode >= 300 { 7232 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 7233 } 7234 output := &ListTagsForResourceOutput{} 7235 out.Result = output 7236 7237 var buff [1024]byte 7238 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7239 7240 body := io.TeeReader(response.Body, ringBuffer) 7241 7242 decoder := json.NewDecoder(body) 7243 decoder.UseNumber() 7244 var shape interface{} 7245 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7246 var snapshot bytes.Buffer 7247 io.Copy(&snapshot, ringBuffer) 7248 err = &smithy.DeserializationError{ 7249 Err: fmt.Errorf("failed to decode response body, %w", err), 7250 Snapshot: snapshot.Bytes(), 7251 } 7252 return out, metadata, err 7253 } 7254 7255 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 7256 if err != nil { 7257 var snapshot bytes.Buffer 7258 io.Copy(&snapshot, ringBuffer) 7259 return out, metadata, &smithy.DeserializationError{ 7260 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7261 Snapshot: snapshot.Bytes(), 7262 } 7263 } 7264 7265 return out, metadata, err 7266} 7267 7268func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7269 var errorBuffer bytes.Buffer 7270 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7271 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7272 } 7273 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7274 7275 errorCode := "UnknownError" 7276 errorMessage := errorCode 7277 7278 code := response.Header.Get("X-Amzn-ErrorType") 7279 if len(code) != 0 { 7280 errorCode = restjson.SanitizeErrorCode(code) 7281 } 7282 7283 var buff [1024]byte 7284 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7285 7286 body := io.TeeReader(errorBody, ringBuffer) 7287 decoder := json.NewDecoder(body) 7288 decoder.UseNumber() 7289 code, message, err := restjson.GetErrorInfo(decoder) 7290 if err != nil { 7291 var snapshot bytes.Buffer 7292 io.Copy(&snapshot, ringBuffer) 7293 err = &smithy.DeserializationError{ 7294 Err: fmt.Errorf("failed to decode response body, %w", err), 7295 Snapshot: snapshot.Bytes(), 7296 } 7297 return err 7298 } 7299 7300 errorBody.Seek(0, io.SeekStart) 7301 if len(code) != 0 { 7302 errorCode = restjson.SanitizeErrorCode(code) 7303 } 7304 if len(message) != 0 { 7305 errorMessage = message 7306 } 7307 7308 switch { 7309 default: 7310 genericError := &smithy.GenericAPIError{ 7311 Code: errorCode, 7312 Message: errorMessage, 7313 } 7314 return genericError 7315 7316 } 7317} 7318 7319func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 7320 if v == nil { 7321 return fmt.Errorf("unexpected nil of type %T", v) 7322 } 7323 if value == nil { 7324 return nil 7325 } 7326 7327 shape, ok := value.(map[string]interface{}) 7328 if !ok { 7329 return fmt.Errorf("unexpected JSON type %v", value) 7330 } 7331 7332 var sv *ListTagsForResourceOutput 7333 if *v == nil { 7334 sv = &ListTagsForResourceOutput{} 7335 } else { 7336 sv = *v 7337 } 7338 7339 for key, value := range shape { 7340 switch key { 7341 case "tags": 7342 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 7343 return err 7344 } 7345 7346 default: 7347 _, _ = key, value 7348 7349 } 7350 } 7351 *v = sv 7352 return nil 7353} 7354 7355type awsRestjson1_deserializeOpPutClassificationExportConfiguration struct { 7356} 7357 7358func (*awsRestjson1_deserializeOpPutClassificationExportConfiguration) ID() string { 7359 return "OperationDeserializer" 7360} 7361 7362func (m *awsRestjson1_deserializeOpPutClassificationExportConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7363 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7364) { 7365 out, metadata, err = next.HandleDeserialize(ctx, in) 7366 if err != nil { 7367 return out, metadata, err 7368 } 7369 7370 response, ok := out.RawResponse.(*smithyhttp.Response) 7371 if !ok { 7372 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7373 } 7374 7375 if response.StatusCode < 200 || response.StatusCode >= 300 { 7376 return out, metadata, awsRestjson1_deserializeOpErrorPutClassificationExportConfiguration(response, &metadata) 7377 } 7378 output := &PutClassificationExportConfigurationOutput{} 7379 out.Result = output 7380 7381 var buff [1024]byte 7382 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7383 7384 body := io.TeeReader(response.Body, ringBuffer) 7385 7386 decoder := json.NewDecoder(body) 7387 decoder.UseNumber() 7388 var shape interface{} 7389 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7390 var snapshot bytes.Buffer 7391 io.Copy(&snapshot, ringBuffer) 7392 err = &smithy.DeserializationError{ 7393 Err: fmt.Errorf("failed to decode response body, %w", err), 7394 Snapshot: snapshot.Bytes(), 7395 } 7396 return out, metadata, err 7397 } 7398 7399 err = awsRestjson1_deserializeOpDocumentPutClassificationExportConfigurationOutput(&output, shape) 7400 if err != nil { 7401 var snapshot bytes.Buffer 7402 io.Copy(&snapshot, ringBuffer) 7403 return out, metadata, &smithy.DeserializationError{ 7404 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7405 Snapshot: snapshot.Bytes(), 7406 } 7407 } 7408 7409 return out, metadata, err 7410} 7411 7412func awsRestjson1_deserializeOpErrorPutClassificationExportConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7413 var errorBuffer bytes.Buffer 7414 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7415 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7416 } 7417 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7418 7419 errorCode := "UnknownError" 7420 errorMessage := errorCode 7421 7422 code := response.Header.Get("X-Amzn-ErrorType") 7423 if len(code) != 0 { 7424 errorCode = restjson.SanitizeErrorCode(code) 7425 } 7426 7427 var buff [1024]byte 7428 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7429 7430 body := io.TeeReader(errorBody, ringBuffer) 7431 decoder := json.NewDecoder(body) 7432 decoder.UseNumber() 7433 code, message, err := restjson.GetErrorInfo(decoder) 7434 if err != nil { 7435 var snapshot bytes.Buffer 7436 io.Copy(&snapshot, ringBuffer) 7437 err = &smithy.DeserializationError{ 7438 Err: fmt.Errorf("failed to decode response body, %w", err), 7439 Snapshot: snapshot.Bytes(), 7440 } 7441 return err 7442 } 7443 7444 errorBody.Seek(0, io.SeekStart) 7445 if len(code) != 0 { 7446 errorCode = restjson.SanitizeErrorCode(code) 7447 } 7448 if len(message) != 0 { 7449 errorMessage = message 7450 } 7451 7452 switch { 7453 case strings.EqualFold("AccessDeniedException", errorCode): 7454 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7455 7456 case strings.EqualFold("ConflictException", errorCode): 7457 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7458 7459 case strings.EqualFold("InternalServerException", errorCode): 7460 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7461 7462 case strings.EqualFold("ResourceNotFoundException", errorCode): 7463 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7464 7465 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7466 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7467 7468 case strings.EqualFold("ThrottlingException", errorCode): 7469 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7470 7471 case strings.EqualFold("ValidationException", errorCode): 7472 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7473 7474 default: 7475 genericError := &smithy.GenericAPIError{ 7476 Code: errorCode, 7477 Message: errorMessage, 7478 } 7479 return genericError 7480 7481 } 7482} 7483 7484func awsRestjson1_deserializeOpDocumentPutClassificationExportConfigurationOutput(v **PutClassificationExportConfigurationOutput, value interface{}) error { 7485 if v == nil { 7486 return fmt.Errorf("unexpected nil of type %T", v) 7487 } 7488 if value == nil { 7489 return nil 7490 } 7491 7492 shape, ok := value.(map[string]interface{}) 7493 if !ok { 7494 return fmt.Errorf("unexpected JSON type %v", value) 7495 } 7496 7497 var sv *PutClassificationExportConfigurationOutput 7498 if *v == nil { 7499 sv = &PutClassificationExportConfigurationOutput{} 7500 } else { 7501 sv = *v 7502 } 7503 7504 for key, value := range shape { 7505 switch key { 7506 case "configuration": 7507 if err := awsRestjson1_deserializeDocumentClassificationExportConfiguration(&sv.Configuration, value); err != nil { 7508 return err 7509 } 7510 7511 default: 7512 _, _ = key, value 7513 7514 } 7515 } 7516 *v = sv 7517 return nil 7518} 7519 7520type awsRestjson1_deserializeOpPutFindingsPublicationConfiguration struct { 7521} 7522 7523func (*awsRestjson1_deserializeOpPutFindingsPublicationConfiguration) ID() string { 7524 return "OperationDeserializer" 7525} 7526 7527func (m *awsRestjson1_deserializeOpPutFindingsPublicationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7528 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7529) { 7530 out, metadata, err = next.HandleDeserialize(ctx, in) 7531 if err != nil { 7532 return out, metadata, err 7533 } 7534 7535 response, ok := out.RawResponse.(*smithyhttp.Response) 7536 if !ok { 7537 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7538 } 7539 7540 if response.StatusCode < 200 || response.StatusCode >= 300 { 7541 return out, metadata, awsRestjson1_deserializeOpErrorPutFindingsPublicationConfiguration(response, &metadata) 7542 } 7543 output := &PutFindingsPublicationConfigurationOutput{} 7544 out.Result = output 7545 7546 return out, metadata, err 7547} 7548 7549func awsRestjson1_deserializeOpErrorPutFindingsPublicationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7550 var errorBuffer bytes.Buffer 7551 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7552 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7553 } 7554 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7555 7556 errorCode := "UnknownError" 7557 errorMessage := errorCode 7558 7559 code := response.Header.Get("X-Amzn-ErrorType") 7560 if len(code) != 0 { 7561 errorCode = restjson.SanitizeErrorCode(code) 7562 } 7563 7564 var buff [1024]byte 7565 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7566 7567 body := io.TeeReader(errorBody, ringBuffer) 7568 decoder := json.NewDecoder(body) 7569 decoder.UseNumber() 7570 code, message, err := restjson.GetErrorInfo(decoder) 7571 if err != nil { 7572 var snapshot bytes.Buffer 7573 io.Copy(&snapshot, ringBuffer) 7574 err = &smithy.DeserializationError{ 7575 Err: fmt.Errorf("failed to decode response body, %w", err), 7576 Snapshot: snapshot.Bytes(), 7577 } 7578 return err 7579 } 7580 7581 errorBody.Seek(0, io.SeekStart) 7582 if len(code) != 0 { 7583 errorCode = restjson.SanitizeErrorCode(code) 7584 } 7585 if len(message) != 0 { 7586 errorMessage = message 7587 } 7588 7589 switch { 7590 case strings.EqualFold("AccessDeniedException", errorCode): 7591 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7592 7593 case strings.EqualFold("ConflictException", errorCode): 7594 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7595 7596 case strings.EqualFold("InternalServerException", errorCode): 7597 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7598 7599 case strings.EqualFold("ResourceNotFoundException", errorCode): 7600 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7601 7602 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7603 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7604 7605 case strings.EqualFold("ThrottlingException", errorCode): 7606 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7607 7608 case strings.EqualFold("ValidationException", errorCode): 7609 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7610 7611 default: 7612 genericError := &smithy.GenericAPIError{ 7613 Code: errorCode, 7614 Message: errorMessage, 7615 } 7616 return genericError 7617 7618 } 7619} 7620 7621type awsRestjson1_deserializeOpTagResource struct { 7622} 7623 7624func (*awsRestjson1_deserializeOpTagResource) ID() string { 7625 return "OperationDeserializer" 7626} 7627 7628func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7629 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7630) { 7631 out, metadata, err = next.HandleDeserialize(ctx, in) 7632 if err != nil { 7633 return out, metadata, err 7634 } 7635 7636 response, ok := out.RawResponse.(*smithyhttp.Response) 7637 if !ok { 7638 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7639 } 7640 7641 if response.StatusCode < 200 || response.StatusCode >= 300 { 7642 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 7643 } 7644 output := &TagResourceOutput{} 7645 out.Result = output 7646 7647 return out, metadata, err 7648} 7649 7650func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7651 var errorBuffer bytes.Buffer 7652 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7653 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7654 } 7655 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7656 7657 errorCode := "UnknownError" 7658 errorMessage := errorCode 7659 7660 code := response.Header.Get("X-Amzn-ErrorType") 7661 if len(code) != 0 { 7662 errorCode = restjson.SanitizeErrorCode(code) 7663 } 7664 7665 var buff [1024]byte 7666 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7667 7668 body := io.TeeReader(errorBody, ringBuffer) 7669 decoder := json.NewDecoder(body) 7670 decoder.UseNumber() 7671 code, message, err := restjson.GetErrorInfo(decoder) 7672 if err != nil { 7673 var snapshot bytes.Buffer 7674 io.Copy(&snapshot, ringBuffer) 7675 err = &smithy.DeserializationError{ 7676 Err: fmt.Errorf("failed to decode response body, %w", err), 7677 Snapshot: snapshot.Bytes(), 7678 } 7679 return err 7680 } 7681 7682 errorBody.Seek(0, io.SeekStart) 7683 if len(code) != 0 { 7684 errorCode = restjson.SanitizeErrorCode(code) 7685 } 7686 if len(message) != 0 { 7687 errorMessage = message 7688 } 7689 7690 switch { 7691 default: 7692 genericError := &smithy.GenericAPIError{ 7693 Code: errorCode, 7694 Message: errorMessage, 7695 } 7696 return genericError 7697 7698 } 7699} 7700 7701type awsRestjson1_deserializeOpTestCustomDataIdentifier struct { 7702} 7703 7704func (*awsRestjson1_deserializeOpTestCustomDataIdentifier) ID() string { 7705 return "OperationDeserializer" 7706} 7707 7708func (m *awsRestjson1_deserializeOpTestCustomDataIdentifier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7709 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7710) { 7711 out, metadata, err = next.HandleDeserialize(ctx, in) 7712 if err != nil { 7713 return out, metadata, err 7714 } 7715 7716 response, ok := out.RawResponse.(*smithyhttp.Response) 7717 if !ok { 7718 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7719 } 7720 7721 if response.StatusCode < 200 || response.StatusCode >= 300 { 7722 return out, metadata, awsRestjson1_deserializeOpErrorTestCustomDataIdentifier(response, &metadata) 7723 } 7724 output := &TestCustomDataIdentifierOutput{} 7725 out.Result = output 7726 7727 var buff [1024]byte 7728 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7729 7730 body := io.TeeReader(response.Body, ringBuffer) 7731 7732 decoder := json.NewDecoder(body) 7733 decoder.UseNumber() 7734 var shape interface{} 7735 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7736 var snapshot bytes.Buffer 7737 io.Copy(&snapshot, ringBuffer) 7738 err = &smithy.DeserializationError{ 7739 Err: fmt.Errorf("failed to decode response body, %w", err), 7740 Snapshot: snapshot.Bytes(), 7741 } 7742 return out, metadata, err 7743 } 7744 7745 err = awsRestjson1_deserializeOpDocumentTestCustomDataIdentifierOutput(&output, shape) 7746 if err != nil { 7747 var snapshot bytes.Buffer 7748 io.Copy(&snapshot, ringBuffer) 7749 return out, metadata, &smithy.DeserializationError{ 7750 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7751 Snapshot: snapshot.Bytes(), 7752 } 7753 } 7754 7755 return out, metadata, err 7756} 7757 7758func awsRestjson1_deserializeOpErrorTestCustomDataIdentifier(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7759 var errorBuffer bytes.Buffer 7760 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7761 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7762 } 7763 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7764 7765 errorCode := "UnknownError" 7766 errorMessage := errorCode 7767 7768 code := response.Header.Get("X-Amzn-ErrorType") 7769 if len(code) != 0 { 7770 errorCode = restjson.SanitizeErrorCode(code) 7771 } 7772 7773 var buff [1024]byte 7774 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7775 7776 body := io.TeeReader(errorBody, ringBuffer) 7777 decoder := json.NewDecoder(body) 7778 decoder.UseNumber() 7779 code, message, err := restjson.GetErrorInfo(decoder) 7780 if err != nil { 7781 var snapshot bytes.Buffer 7782 io.Copy(&snapshot, ringBuffer) 7783 err = &smithy.DeserializationError{ 7784 Err: fmt.Errorf("failed to decode response body, %w", err), 7785 Snapshot: snapshot.Bytes(), 7786 } 7787 return err 7788 } 7789 7790 errorBody.Seek(0, io.SeekStart) 7791 if len(code) != 0 { 7792 errorCode = restjson.SanitizeErrorCode(code) 7793 } 7794 if len(message) != 0 { 7795 errorMessage = message 7796 } 7797 7798 switch { 7799 case strings.EqualFold("AccessDeniedException", errorCode): 7800 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7801 7802 case strings.EqualFold("ConflictException", errorCode): 7803 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 7804 7805 case strings.EqualFold("InternalServerException", errorCode): 7806 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 7807 7808 case strings.EqualFold("ResourceNotFoundException", errorCode): 7809 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7810 7811 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 7812 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 7813 7814 case strings.EqualFold("ThrottlingException", errorCode): 7815 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 7816 7817 case strings.EqualFold("ValidationException", errorCode): 7818 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7819 7820 default: 7821 genericError := &smithy.GenericAPIError{ 7822 Code: errorCode, 7823 Message: errorMessage, 7824 } 7825 return genericError 7826 7827 } 7828} 7829 7830func awsRestjson1_deserializeOpDocumentTestCustomDataIdentifierOutput(v **TestCustomDataIdentifierOutput, value interface{}) error { 7831 if v == nil { 7832 return fmt.Errorf("unexpected nil of type %T", v) 7833 } 7834 if value == nil { 7835 return nil 7836 } 7837 7838 shape, ok := value.(map[string]interface{}) 7839 if !ok { 7840 return fmt.Errorf("unexpected JSON type %v", value) 7841 } 7842 7843 var sv *TestCustomDataIdentifierOutput 7844 if *v == nil { 7845 sv = &TestCustomDataIdentifierOutput{} 7846 } else { 7847 sv = *v 7848 } 7849 7850 for key, value := range shape { 7851 switch key { 7852 case "matchCount": 7853 if value != nil { 7854 jtv, ok := value.(json.Number) 7855 if !ok { 7856 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 7857 } 7858 i64, err := jtv.Int64() 7859 if err != nil { 7860 return err 7861 } 7862 sv.MatchCount = int32(i64) 7863 } 7864 7865 default: 7866 _, _ = key, value 7867 7868 } 7869 } 7870 *v = sv 7871 return nil 7872} 7873 7874type awsRestjson1_deserializeOpUntagResource struct { 7875} 7876 7877func (*awsRestjson1_deserializeOpUntagResource) ID() string { 7878 return "OperationDeserializer" 7879} 7880 7881func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7882 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7883) { 7884 out, metadata, err = next.HandleDeserialize(ctx, in) 7885 if err != nil { 7886 return out, metadata, err 7887 } 7888 7889 response, ok := out.RawResponse.(*smithyhttp.Response) 7890 if !ok { 7891 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7892 } 7893 7894 if response.StatusCode < 200 || response.StatusCode >= 300 { 7895 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 7896 } 7897 output := &UntagResourceOutput{} 7898 out.Result = output 7899 7900 return out, metadata, err 7901} 7902 7903func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7904 var errorBuffer bytes.Buffer 7905 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7906 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7907 } 7908 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7909 7910 errorCode := "UnknownError" 7911 errorMessage := errorCode 7912 7913 code := response.Header.Get("X-Amzn-ErrorType") 7914 if len(code) != 0 { 7915 errorCode = restjson.SanitizeErrorCode(code) 7916 } 7917 7918 var buff [1024]byte 7919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7920 7921 body := io.TeeReader(errorBody, ringBuffer) 7922 decoder := json.NewDecoder(body) 7923 decoder.UseNumber() 7924 code, message, err := restjson.GetErrorInfo(decoder) 7925 if err != nil { 7926 var snapshot bytes.Buffer 7927 io.Copy(&snapshot, ringBuffer) 7928 err = &smithy.DeserializationError{ 7929 Err: fmt.Errorf("failed to decode response body, %w", err), 7930 Snapshot: snapshot.Bytes(), 7931 } 7932 return err 7933 } 7934 7935 errorBody.Seek(0, io.SeekStart) 7936 if len(code) != 0 { 7937 errorCode = restjson.SanitizeErrorCode(code) 7938 } 7939 if len(message) != 0 { 7940 errorMessage = message 7941 } 7942 7943 switch { 7944 default: 7945 genericError := &smithy.GenericAPIError{ 7946 Code: errorCode, 7947 Message: errorMessage, 7948 } 7949 return genericError 7950 7951 } 7952} 7953 7954type awsRestjson1_deserializeOpUpdateClassificationJob struct { 7955} 7956 7957func (*awsRestjson1_deserializeOpUpdateClassificationJob) ID() string { 7958 return "OperationDeserializer" 7959} 7960 7961func (m *awsRestjson1_deserializeOpUpdateClassificationJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7962 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7963) { 7964 out, metadata, err = next.HandleDeserialize(ctx, in) 7965 if err != nil { 7966 return out, metadata, err 7967 } 7968 7969 response, ok := out.RawResponse.(*smithyhttp.Response) 7970 if !ok { 7971 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7972 } 7973 7974 if response.StatusCode < 200 || response.StatusCode >= 300 { 7975 return out, metadata, awsRestjson1_deserializeOpErrorUpdateClassificationJob(response, &metadata) 7976 } 7977 output := &UpdateClassificationJobOutput{} 7978 out.Result = output 7979 7980 return out, metadata, err 7981} 7982 7983func awsRestjson1_deserializeOpErrorUpdateClassificationJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7984 var errorBuffer bytes.Buffer 7985 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7986 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7987 } 7988 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7989 7990 errorCode := "UnknownError" 7991 errorMessage := errorCode 7992 7993 code := response.Header.Get("X-Amzn-ErrorType") 7994 if len(code) != 0 { 7995 errorCode = restjson.SanitizeErrorCode(code) 7996 } 7997 7998 var buff [1024]byte 7999 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8000 8001 body := io.TeeReader(errorBody, ringBuffer) 8002 decoder := json.NewDecoder(body) 8003 decoder.UseNumber() 8004 code, message, err := restjson.GetErrorInfo(decoder) 8005 if err != nil { 8006 var snapshot bytes.Buffer 8007 io.Copy(&snapshot, ringBuffer) 8008 err = &smithy.DeserializationError{ 8009 Err: fmt.Errorf("failed to decode response body, %w", err), 8010 Snapshot: snapshot.Bytes(), 8011 } 8012 return err 8013 } 8014 8015 errorBody.Seek(0, io.SeekStart) 8016 if len(code) != 0 { 8017 errorCode = restjson.SanitizeErrorCode(code) 8018 } 8019 if len(message) != 0 { 8020 errorMessage = message 8021 } 8022 8023 switch { 8024 case strings.EqualFold("AccessDeniedException", errorCode): 8025 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8026 8027 case strings.EqualFold("ConflictException", errorCode): 8028 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 8029 8030 case strings.EqualFold("InternalServerException", errorCode): 8031 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 8032 8033 case strings.EqualFold("ResourceNotFoundException", errorCode): 8034 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8035 8036 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 8037 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 8038 8039 case strings.EqualFold("ThrottlingException", errorCode): 8040 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 8041 8042 case strings.EqualFold("ValidationException", errorCode): 8043 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8044 8045 default: 8046 genericError := &smithy.GenericAPIError{ 8047 Code: errorCode, 8048 Message: errorMessage, 8049 } 8050 return genericError 8051 8052 } 8053} 8054 8055type awsRestjson1_deserializeOpUpdateFindingsFilter struct { 8056} 8057 8058func (*awsRestjson1_deserializeOpUpdateFindingsFilter) ID() string { 8059 return "OperationDeserializer" 8060} 8061 8062func (m *awsRestjson1_deserializeOpUpdateFindingsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8063 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8064) { 8065 out, metadata, err = next.HandleDeserialize(ctx, in) 8066 if err != nil { 8067 return out, metadata, err 8068 } 8069 8070 response, ok := out.RawResponse.(*smithyhttp.Response) 8071 if !ok { 8072 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8073 } 8074 8075 if response.StatusCode < 200 || response.StatusCode >= 300 { 8076 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFindingsFilter(response, &metadata) 8077 } 8078 output := &UpdateFindingsFilterOutput{} 8079 out.Result = output 8080 8081 var buff [1024]byte 8082 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8083 8084 body := io.TeeReader(response.Body, ringBuffer) 8085 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 out, metadata, err 8097 } 8098 8099 err = awsRestjson1_deserializeOpDocumentUpdateFindingsFilterOutput(&output, shape) 8100 if err != nil { 8101 var snapshot bytes.Buffer 8102 io.Copy(&snapshot, ringBuffer) 8103 return out, metadata, &smithy.DeserializationError{ 8104 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8105 Snapshot: snapshot.Bytes(), 8106 } 8107 } 8108 8109 return out, metadata, err 8110} 8111 8112func awsRestjson1_deserializeOpErrorUpdateFindingsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8113 var errorBuffer bytes.Buffer 8114 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8115 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8116 } 8117 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8118 8119 errorCode := "UnknownError" 8120 errorMessage := errorCode 8121 8122 code := response.Header.Get("X-Amzn-ErrorType") 8123 if len(code) != 0 { 8124 errorCode = restjson.SanitizeErrorCode(code) 8125 } 8126 8127 var buff [1024]byte 8128 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8129 8130 body := io.TeeReader(errorBody, ringBuffer) 8131 decoder := json.NewDecoder(body) 8132 decoder.UseNumber() 8133 code, message, err := restjson.GetErrorInfo(decoder) 8134 if err != nil { 8135 var snapshot bytes.Buffer 8136 io.Copy(&snapshot, ringBuffer) 8137 err = &smithy.DeserializationError{ 8138 Err: fmt.Errorf("failed to decode response body, %w", err), 8139 Snapshot: snapshot.Bytes(), 8140 } 8141 return err 8142 } 8143 8144 errorBody.Seek(0, io.SeekStart) 8145 if len(code) != 0 { 8146 errorCode = restjson.SanitizeErrorCode(code) 8147 } 8148 if len(message) != 0 { 8149 errorMessage = message 8150 } 8151 8152 switch { 8153 case strings.EqualFold("AccessDeniedException", errorCode): 8154 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8155 8156 case strings.EqualFold("ConflictException", errorCode): 8157 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 8158 8159 case strings.EqualFold("InternalServerException", errorCode): 8160 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 8161 8162 case strings.EqualFold("ResourceNotFoundException", errorCode): 8163 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8164 8165 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 8166 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 8167 8168 case strings.EqualFold("ThrottlingException", errorCode): 8169 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 8170 8171 case strings.EqualFold("ValidationException", errorCode): 8172 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8173 8174 default: 8175 genericError := &smithy.GenericAPIError{ 8176 Code: errorCode, 8177 Message: errorMessage, 8178 } 8179 return genericError 8180 8181 } 8182} 8183 8184func awsRestjson1_deserializeOpDocumentUpdateFindingsFilterOutput(v **UpdateFindingsFilterOutput, value interface{}) error { 8185 if v == nil { 8186 return fmt.Errorf("unexpected nil of type %T", v) 8187 } 8188 if value == nil { 8189 return nil 8190 } 8191 8192 shape, ok := value.(map[string]interface{}) 8193 if !ok { 8194 return fmt.Errorf("unexpected JSON type %v", value) 8195 } 8196 8197 var sv *UpdateFindingsFilterOutput 8198 if *v == nil { 8199 sv = &UpdateFindingsFilterOutput{} 8200 } else { 8201 sv = *v 8202 } 8203 8204 for key, value := range shape { 8205 switch key { 8206 case "arn": 8207 if value != nil { 8208 jtv, ok := value.(string) 8209 if !ok { 8210 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 8211 } 8212 sv.Arn = ptr.String(jtv) 8213 } 8214 8215 case "id": 8216 if value != nil { 8217 jtv, ok := value.(string) 8218 if !ok { 8219 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 8220 } 8221 sv.Id = ptr.String(jtv) 8222 } 8223 8224 default: 8225 _, _ = key, value 8226 8227 } 8228 } 8229 *v = sv 8230 return nil 8231} 8232 8233type awsRestjson1_deserializeOpUpdateMacieSession struct { 8234} 8235 8236func (*awsRestjson1_deserializeOpUpdateMacieSession) ID() string { 8237 return "OperationDeserializer" 8238} 8239 8240func (m *awsRestjson1_deserializeOpUpdateMacieSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8241 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8242) { 8243 out, metadata, err = next.HandleDeserialize(ctx, in) 8244 if err != nil { 8245 return out, metadata, err 8246 } 8247 8248 response, ok := out.RawResponse.(*smithyhttp.Response) 8249 if !ok { 8250 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8251 } 8252 8253 if response.StatusCode < 200 || response.StatusCode >= 300 { 8254 return out, metadata, awsRestjson1_deserializeOpErrorUpdateMacieSession(response, &metadata) 8255 } 8256 output := &UpdateMacieSessionOutput{} 8257 out.Result = output 8258 8259 return out, metadata, err 8260} 8261 8262func awsRestjson1_deserializeOpErrorUpdateMacieSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8263 var errorBuffer bytes.Buffer 8264 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8265 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8266 } 8267 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8268 8269 errorCode := "UnknownError" 8270 errorMessage := errorCode 8271 8272 code := response.Header.Get("X-Amzn-ErrorType") 8273 if len(code) != 0 { 8274 errorCode = restjson.SanitizeErrorCode(code) 8275 } 8276 8277 var buff [1024]byte 8278 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8279 8280 body := io.TeeReader(errorBody, ringBuffer) 8281 decoder := json.NewDecoder(body) 8282 decoder.UseNumber() 8283 code, message, err := restjson.GetErrorInfo(decoder) 8284 if err != nil { 8285 var snapshot bytes.Buffer 8286 io.Copy(&snapshot, ringBuffer) 8287 err = &smithy.DeserializationError{ 8288 Err: fmt.Errorf("failed to decode response body, %w", err), 8289 Snapshot: snapshot.Bytes(), 8290 } 8291 return err 8292 } 8293 8294 errorBody.Seek(0, io.SeekStart) 8295 if len(code) != 0 { 8296 errorCode = restjson.SanitizeErrorCode(code) 8297 } 8298 if len(message) != 0 { 8299 errorMessage = message 8300 } 8301 8302 switch { 8303 case strings.EqualFold("AccessDeniedException", errorCode): 8304 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8305 8306 case strings.EqualFold("ConflictException", errorCode): 8307 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 8308 8309 case strings.EqualFold("InternalServerException", errorCode): 8310 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 8311 8312 case strings.EqualFold("ResourceNotFoundException", errorCode): 8313 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8314 8315 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 8316 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 8317 8318 case strings.EqualFold("ThrottlingException", errorCode): 8319 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 8320 8321 case strings.EqualFold("ValidationException", errorCode): 8322 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8323 8324 default: 8325 genericError := &smithy.GenericAPIError{ 8326 Code: errorCode, 8327 Message: errorMessage, 8328 } 8329 return genericError 8330 8331 } 8332} 8333 8334type awsRestjson1_deserializeOpUpdateMemberSession struct { 8335} 8336 8337func (*awsRestjson1_deserializeOpUpdateMemberSession) ID() string { 8338 return "OperationDeserializer" 8339} 8340 8341func (m *awsRestjson1_deserializeOpUpdateMemberSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8342 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8343) { 8344 out, metadata, err = next.HandleDeserialize(ctx, in) 8345 if err != nil { 8346 return out, metadata, err 8347 } 8348 8349 response, ok := out.RawResponse.(*smithyhttp.Response) 8350 if !ok { 8351 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8352 } 8353 8354 if response.StatusCode < 200 || response.StatusCode >= 300 { 8355 return out, metadata, awsRestjson1_deserializeOpErrorUpdateMemberSession(response, &metadata) 8356 } 8357 output := &UpdateMemberSessionOutput{} 8358 out.Result = output 8359 8360 return out, metadata, err 8361} 8362 8363func awsRestjson1_deserializeOpErrorUpdateMemberSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8364 var errorBuffer bytes.Buffer 8365 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8366 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8367 } 8368 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8369 8370 errorCode := "UnknownError" 8371 errorMessage := errorCode 8372 8373 code := response.Header.Get("X-Amzn-ErrorType") 8374 if len(code) != 0 { 8375 errorCode = restjson.SanitizeErrorCode(code) 8376 } 8377 8378 var buff [1024]byte 8379 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8380 8381 body := io.TeeReader(errorBody, ringBuffer) 8382 decoder := json.NewDecoder(body) 8383 decoder.UseNumber() 8384 code, message, err := restjson.GetErrorInfo(decoder) 8385 if err != nil { 8386 var snapshot bytes.Buffer 8387 io.Copy(&snapshot, ringBuffer) 8388 err = &smithy.DeserializationError{ 8389 Err: fmt.Errorf("failed to decode response body, %w", err), 8390 Snapshot: snapshot.Bytes(), 8391 } 8392 return err 8393 } 8394 8395 errorBody.Seek(0, io.SeekStart) 8396 if len(code) != 0 { 8397 errorCode = restjson.SanitizeErrorCode(code) 8398 } 8399 if len(message) != 0 { 8400 errorMessage = message 8401 } 8402 8403 switch { 8404 case strings.EqualFold("AccessDeniedException", errorCode): 8405 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8406 8407 case strings.EqualFold("ConflictException", errorCode): 8408 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 8409 8410 case strings.EqualFold("InternalServerException", errorCode): 8411 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 8412 8413 case strings.EqualFold("ResourceNotFoundException", errorCode): 8414 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8415 8416 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 8417 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 8418 8419 case strings.EqualFold("ThrottlingException", errorCode): 8420 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 8421 8422 case strings.EqualFold("ValidationException", errorCode): 8423 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8424 8425 default: 8426 genericError := &smithy.GenericAPIError{ 8427 Code: errorCode, 8428 Message: errorMessage, 8429 } 8430 return genericError 8431 8432 } 8433} 8434 8435type awsRestjson1_deserializeOpUpdateOrganizationConfiguration struct { 8436} 8437 8438func (*awsRestjson1_deserializeOpUpdateOrganizationConfiguration) ID() string { 8439 return "OperationDeserializer" 8440} 8441 8442func (m *awsRestjson1_deserializeOpUpdateOrganizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8443 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8444) { 8445 out, metadata, err = next.HandleDeserialize(ctx, in) 8446 if err != nil { 8447 return out, metadata, err 8448 } 8449 8450 response, ok := out.RawResponse.(*smithyhttp.Response) 8451 if !ok { 8452 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8453 } 8454 8455 if response.StatusCode < 200 || response.StatusCode >= 300 { 8456 return out, metadata, awsRestjson1_deserializeOpErrorUpdateOrganizationConfiguration(response, &metadata) 8457 } 8458 output := &UpdateOrganizationConfigurationOutput{} 8459 out.Result = output 8460 8461 return out, metadata, err 8462} 8463 8464func awsRestjson1_deserializeOpErrorUpdateOrganizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8465 var errorBuffer bytes.Buffer 8466 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8467 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8468 } 8469 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8470 8471 errorCode := "UnknownError" 8472 errorMessage := errorCode 8473 8474 code := response.Header.Get("X-Amzn-ErrorType") 8475 if len(code) != 0 { 8476 errorCode = restjson.SanitizeErrorCode(code) 8477 } 8478 8479 var buff [1024]byte 8480 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8481 8482 body := io.TeeReader(errorBody, ringBuffer) 8483 decoder := json.NewDecoder(body) 8484 decoder.UseNumber() 8485 code, message, err := restjson.GetErrorInfo(decoder) 8486 if err != nil { 8487 var snapshot bytes.Buffer 8488 io.Copy(&snapshot, ringBuffer) 8489 err = &smithy.DeserializationError{ 8490 Err: fmt.Errorf("failed to decode response body, %w", err), 8491 Snapshot: snapshot.Bytes(), 8492 } 8493 return err 8494 } 8495 8496 errorBody.Seek(0, io.SeekStart) 8497 if len(code) != 0 { 8498 errorCode = restjson.SanitizeErrorCode(code) 8499 } 8500 if len(message) != 0 { 8501 errorMessage = message 8502 } 8503 8504 switch { 8505 case strings.EqualFold("AccessDeniedException", errorCode): 8506 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8507 8508 case strings.EqualFold("ConflictException", errorCode): 8509 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 8510 8511 case strings.EqualFold("InternalServerException", errorCode): 8512 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 8513 8514 case strings.EqualFold("ResourceNotFoundException", errorCode): 8515 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8516 8517 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 8518 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 8519 8520 case strings.EqualFold("ThrottlingException", errorCode): 8521 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 8522 8523 case strings.EqualFold("ValidationException", errorCode): 8524 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8525 8526 default: 8527 genericError := &smithy.GenericAPIError{ 8528 Code: errorCode, 8529 Message: errorMessage, 8530 } 8531 return genericError 8532 8533 } 8534} 8535 8536func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8537 output := &types.AccessDeniedException{} 8538 var buff [1024]byte 8539 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8540 8541 body := io.TeeReader(errorBody, ringBuffer) 8542 decoder := json.NewDecoder(body) 8543 decoder.UseNumber() 8544 var shape interface{} 8545 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8546 var snapshot bytes.Buffer 8547 io.Copy(&snapshot, ringBuffer) 8548 err = &smithy.DeserializationError{ 8549 Err: fmt.Errorf("failed to decode response body, %w", err), 8550 Snapshot: snapshot.Bytes(), 8551 } 8552 return err 8553 } 8554 8555 err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape) 8556 8557 if err != nil { 8558 var snapshot bytes.Buffer 8559 io.Copy(&snapshot, ringBuffer) 8560 err = &smithy.DeserializationError{ 8561 Err: fmt.Errorf("failed to decode response body, %w", err), 8562 Snapshot: snapshot.Bytes(), 8563 } 8564 return err 8565 } 8566 8567 errorBody.Seek(0, io.SeekStart) 8568 8569 return output 8570} 8571 8572func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8573 output := &types.ConflictException{} 8574 var buff [1024]byte 8575 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8576 8577 body := io.TeeReader(errorBody, ringBuffer) 8578 decoder := json.NewDecoder(body) 8579 decoder.UseNumber() 8580 var shape interface{} 8581 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8582 var snapshot bytes.Buffer 8583 io.Copy(&snapshot, ringBuffer) 8584 err = &smithy.DeserializationError{ 8585 Err: fmt.Errorf("failed to decode response body, %w", err), 8586 Snapshot: snapshot.Bytes(), 8587 } 8588 return err 8589 } 8590 8591 err := awsRestjson1_deserializeDocumentConflictException(&output, shape) 8592 8593 if err != nil { 8594 var snapshot bytes.Buffer 8595 io.Copy(&snapshot, ringBuffer) 8596 err = &smithy.DeserializationError{ 8597 Err: fmt.Errorf("failed to decode response body, %w", err), 8598 Snapshot: snapshot.Bytes(), 8599 } 8600 return err 8601 } 8602 8603 errorBody.Seek(0, io.SeekStart) 8604 8605 return output 8606} 8607 8608func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8609 output := &types.InternalServerException{} 8610 var buff [1024]byte 8611 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8612 8613 body := io.TeeReader(errorBody, ringBuffer) 8614 decoder := json.NewDecoder(body) 8615 decoder.UseNumber() 8616 var shape interface{} 8617 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8618 var snapshot bytes.Buffer 8619 io.Copy(&snapshot, ringBuffer) 8620 err = &smithy.DeserializationError{ 8621 Err: fmt.Errorf("failed to decode response body, %w", err), 8622 Snapshot: snapshot.Bytes(), 8623 } 8624 return err 8625 } 8626 8627 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape) 8628 8629 if err != nil { 8630 var snapshot bytes.Buffer 8631 io.Copy(&snapshot, ringBuffer) 8632 err = &smithy.DeserializationError{ 8633 Err: fmt.Errorf("failed to decode response body, %w", err), 8634 Snapshot: snapshot.Bytes(), 8635 } 8636 return err 8637 } 8638 8639 errorBody.Seek(0, io.SeekStart) 8640 8641 return output 8642} 8643 8644func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8645 output := &types.ResourceNotFoundException{} 8646 var buff [1024]byte 8647 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8648 8649 body := io.TeeReader(errorBody, ringBuffer) 8650 decoder := json.NewDecoder(body) 8651 decoder.UseNumber() 8652 var shape interface{} 8653 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8654 var snapshot bytes.Buffer 8655 io.Copy(&snapshot, ringBuffer) 8656 err = &smithy.DeserializationError{ 8657 Err: fmt.Errorf("failed to decode response body, %w", err), 8658 Snapshot: snapshot.Bytes(), 8659 } 8660 return err 8661 } 8662 8663 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 8664 8665 if err != nil { 8666 var snapshot bytes.Buffer 8667 io.Copy(&snapshot, ringBuffer) 8668 err = &smithy.DeserializationError{ 8669 Err: fmt.Errorf("failed to decode response body, %w", err), 8670 Snapshot: snapshot.Bytes(), 8671 } 8672 return err 8673 } 8674 8675 errorBody.Seek(0, io.SeekStart) 8676 8677 return output 8678} 8679 8680func awsRestjson1_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8681 output := &types.ServiceQuotaExceededException{} 8682 var buff [1024]byte 8683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8684 8685 body := io.TeeReader(errorBody, ringBuffer) 8686 decoder := json.NewDecoder(body) 8687 decoder.UseNumber() 8688 var shape interface{} 8689 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8690 var snapshot bytes.Buffer 8691 io.Copy(&snapshot, ringBuffer) 8692 err = &smithy.DeserializationError{ 8693 Err: fmt.Errorf("failed to decode response body, %w", err), 8694 Snapshot: snapshot.Bytes(), 8695 } 8696 return err 8697 } 8698 8699 err := awsRestjson1_deserializeDocumentServiceQuotaExceededException(&output, shape) 8700 8701 if err != nil { 8702 var snapshot bytes.Buffer 8703 io.Copy(&snapshot, ringBuffer) 8704 err = &smithy.DeserializationError{ 8705 Err: fmt.Errorf("failed to decode response body, %w", err), 8706 Snapshot: snapshot.Bytes(), 8707 } 8708 return err 8709 } 8710 8711 errorBody.Seek(0, io.SeekStart) 8712 8713 return output 8714} 8715 8716func awsRestjson1_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8717 output := &types.ThrottlingException{} 8718 var buff [1024]byte 8719 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8720 8721 body := io.TeeReader(errorBody, ringBuffer) 8722 decoder := json.NewDecoder(body) 8723 decoder.UseNumber() 8724 var shape interface{} 8725 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8726 var snapshot bytes.Buffer 8727 io.Copy(&snapshot, ringBuffer) 8728 err = &smithy.DeserializationError{ 8729 Err: fmt.Errorf("failed to decode response body, %w", err), 8730 Snapshot: snapshot.Bytes(), 8731 } 8732 return err 8733 } 8734 8735 err := awsRestjson1_deserializeDocumentThrottlingException(&output, shape) 8736 8737 if err != nil { 8738 var snapshot bytes.Buffer 8739 io.Copy(&snapshot, ringBuffer) 8740 err = &smithy.DeserializationError{ 8741 Err: fmt.Errorf("failed to decode response body, %w", err), 8742 Snapshot: snapshot.Bytes(), 8743 } 8744 return err 8745 } 8746 8747 errorBody.Seek(0, io.SeekStart) 8748 8749 return output 8750} 8751 8752func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8753 output := &types.ValidationException{} 8754 var buff [1024]byte 8755 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8756 8757 body := io.TeeReader(errorBody, ringBuffer) 8758 decoder := json.NewDecoder(body) 8759 decoder.UseNumber() 8760 var shape interface{} 8761 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8762 var snapshot bytes.Buffer 8763 io.Copy(&snapshot, ringBuffer) 8764 err = &smithy.DeserializationError{ 8765 Err: fmt.Errorf("failed to decode response body, %w", err), 8766 Snapshot: snapshot.Bytes(), 8767 } 8768 return err 8769 } 8770 8771 err := awsRestjson1_deserializeDocumentValidationException(&output, shape) 8772 8773 if err != nil { 8774 var snapshot bytes.Buffer 8775 io.Copy(&snapshot, ringBuffer) 8776 err = &smithy.DeserializationError{ 8777 Err: fmt.Errorf("failed to decode response body, %w", err), 8778 Snapshot: snapshot.Bytes(), 8779 } 8780 return err 8781 } 8782 8783 errorBody.Seek(0, io.SeekStart) 8784 8785 return output 8786} 8787 8788func awsRestjson1_deserializeDocument__listOf__string(v *[]string, value interface{}) error { 8789 if v == nil { 8790 return fmt.Errorf("unexpected nil of type %T", v) 8791 } 8792 if value == nil { 8793 return nil 8794 } 8795 8796 shape, ok := value.([]interface{}) 8797 if !ok { 8798 return fmt.Errorf("unexpected JSON type %v", value) 8799 } 8800 8801 var cv []string 8802 if *v == nil { 8803 cv = []string{} 8804 } else { 8805 cv = *v 8806 } 8807 8808 for _, value := range shape { 8809 var col string 8810 if value != nil { 8811 jtv, ok := value.(string) 8812 if !ok { 8813 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 8814 } 8815 col = jtv 8816 } 8817 cv = append(cv, col) 8818 8819 } 8820 *v = cv 8821 return nil 8822} 8823 8824func awsRestjson1_deserializeDocument__listOfAdminAccount(v *[]types.AdminAccount, value interface{}) error { 8825 if v == nil { 8826 return fmt.Errorf("unexpected nil of type %T", v) 8827 } 8828 if value == nil { 8829 return nil 8830 } 8831 8832 shape, ok := value.([]interface{}) 8833 if !ok { 8834 return fmt.Errorf("unexpected JSON type %v", value) 8835 } 8836 8837 var cv []types.AdminAccount 8838 if *v == nil { 8839 cv = []types.AdminAccount{} 8840 } else { 8841 cv = *v 8842 } 8843 8844 for _, value := range shape { 8845 var col types.AdminAccount 8846 destAddr := &col 8847 if err := awsRestjson1_deserializeDocumentAdminAccount(&destAddr, value); err != nil { 8848 return err 8849 } 8850 col = *destAddr 8851 cv = append(cv, col) 8852 8853 } 8854 *v = cv 8855 return nil 8856} 8857 8858func awsRestjson1_deserializeDocument__listOfBatchGetCustomDataIdentifierSummary(v *[]types.BatchGetCustomDataIdentifierSummary, value interface{}) error { 8859 if v == nil { 8860 return fmt.Errorf("unexpected nil of type %T", v) 8861 } 8862 if value == nil { 8863 return nil 8864 } 8865 8866 shape, ok := value.([]interface{}) 8867 if !ok { 8868 return fmt.Errorf("unexpected JSON type %v", value) 8869 } 8870 8871 var cv []types.BatchGetCustomDataIdentifierSummary 8872 if *v == nil { 8873 cv = []types.BatchGetCustomDataIdentifierSummary{} 8874 } else { 8875 cv = *v 8876 } 8877 8878 for _, value := range shape { 8879 var col types.BatchGetCustomDataIdentifierSummary 8880 destAddr := &col 8881 if err := awsRestjson1_deserializeDocumentBatchGetCustomDataIdentifierSummary(&destAddr, value); err != nil { 8882 return err 8883 } 8884 col = *destAddr 8885 cv = append(cv, col) 8886 8887 } 8888 *v = cv 8889 return nil 8890} 8891 8892func awsRestjson1_deserializeDocument__listOfBucketMetadata(v *[]types.BucketMetadata, value interface{}) error { 8893 if v == nil { 8894 return fmt.Errorf("unexpected nil of type %T", v) 8895 } 8896 if value == nil { 8897 return nil 8898 } 8899 8900 shape, ok := value.([]interface{}) 8901 if !ok { 8902 return fmt.Errorf("unexpected JSON type %v", value) 8903 } 8904 8905 var cv []types.BucketMetadata 8906 if *v == nil { 8907 cv = []types.BucketMetadata{} 8908 } else { 8909 cv = *v 8910 } 8911 8912 for _, value := range shape { 8913 var col types.BucketMetadata 8914 destAddr := &col 8915 if err := awsRestjson1_deserializeDocumentBucketMetadata(&destAddr, value); err != nil { 8916 return err 8917 } 8918 col = *destAddr 8919 cv = append(cv, col) 8920 8921 } 8922 *v = cv 8923 return nil 8924} 8925 8926func awsRestjson1_deserializeDocument__listOfCustomDataIdentifierSummary(v *[]types.CustomDataIdentifierSummary, value interface{}) error { 8927 if v == nil { 8928 return fmt.Errorf("unexpected nil of type %T", v) 8929 } 8930 if value == nil { 8931 return nil 8932 } 8933 8934 shape, ok := value.([]interface{}) 8935 if !ok { 8936 return fmt.Errorf("unexpected JSON type %v", value) 8937 } 8938 8939 var cv []types.CustomDataIdentifierSummary 8940 if *v == nil { 8941 cv = []types.CustomDataIdentifierSummary{} 8942 } else { 8943 cv = *v 8944 } 8945 8946 for _, value := range shape { 8947 var col types.CustomDataIdentifierSummary 8948 destAddr := &col 8949 if err := awsRestjson1_deserializeDocumentCustomDataIdentifierSummary(&destAddr, value); err != nil { 8950 return err 8951 } 8952 col = *destAddr 8953 cv = append(cv, col) 8954 8955 } 8956 *v = cv 8957 return nil 8958} 8959 8960func awsRestjson1_deserializeDocument__listOfFinding(v *[]types.Finding, value interface{}) error { 8961 if v == nil { 8962 return fmt.Errorf("unexpected nil of type %T", v) 8963 } 8964 if value == nil { 8965 return nil 8966 } 8967 8968 shape, ok := value.([]interface{}) 8969 if !ok { 8970 return fmt.Errorf("unexpected JSON type %v", value) 8971 } 8972 8973 var cv []types.Finding 8974 if *v == nil { 8975 cv = []types.Finding{} 8976 } else { 8977 cv = *v 8978 } 8979 8980 for _, value := range shape { 8981 var col types.Finding 8982 destAddr := &col 8983 if err := awsRestjson1_deserializeDocumentFinding(&destAddr, value); err != nil { 8984 return err 8985 } 8986 col = *destAddr 8987 cv = append(cv, col) 8988 8989 } 8990 *v = cv 8991 return nil 8992} 8993 8994func awsRestjson1_deserializeDocument__listOfFindingsFilterListItem(v *[]types.FindingsFilterListItem, value interface{}) error { 8995 if v == nil { 8996 return fmt.Errorf("unexpected nil of type %T", v) 8997 } 8998 if value == nil { 8999 return nil 9000 } 9001 9002 shape, ok := value.([]interface{}) 9003 if !ok { 9004 return fmt.Errorf("unexpected JSON type %v", value) 9005 } 9006 9007 var cv []types.FindingsFilterListItem 9008 if *v == nil { 9009 cv = []types.FindingsFilterListItem{} 9010 } else { 9011 cv = *v 9012 } 9013 9014 for _, value := range shape { 9015 var col types.FindingsFilterListItem 9016 destAddr := &col 9017 if err := awsRestjson1_deserializeDocumentFindingsFilterListItem(&destAddr, value); err != nil { 9018 return err 9019 } 9020 col = *destAddr 9021 cv = append(cv, col) 9022 9023 } 9024 *v = cv 9025 return nil 9026} 9027 9028func awsRestjson1_deserializeDocument__listOfGroupCount(v *[]types.GroupCount, value interface{}) error { 9029 if v == nil { 9030 return fmt.Errorf("unexpected nil of type %T", v) 9031 } 9032 if value == nil { 9033 return nil 9034 } 9035 9036 shape, ok := value.([]interface{}) 9037 if !ok { 9038 return fmt.Errorf("unexpected JSON type %v", value) 9039 } 9040 9041 var cv []types.GroupCount 9042 if *v == nil { 9043 cv = []types.GroupCount{} 9044 } else { 9045 cv = *v 9046 } 9047 9048 for _, value := range shape { 9049 var col types.GroupCount 9050 destAddr := &col 9051 if err := awsRestjson1_deserializeDocumentGroupCount(&destAddr, value); err != nil { 9052 return err 9053 } 9054 col = *destAddr 9055 cv = append(cv, col) 9056 9057 } 9058 *v = cv 9059 return nil 9060} 9061 9062func awsRestjson1_deserializeDocument__listOfInvitation(v *[]types.Invitation, value interface{}) error { 9063 if v == nil { 9064 return fmt.Errorf("unexpected nil of type %T", v) 9065 } 9066 if value == nil { 9067 return nil 9068 } 9069 9070 shape, ok := value.([]interface{}) 9071 if !ok { 9072 return fmt.Errorf("unexpected JSON type %v", value) 9073 } 9074 9075 var cv []types.Invitation 9076 if *v == nil { 9077 cv = []types.Invitation{} 9078 } else { 9079 cv = *v 9080 } 9081 9082 for _, value := range shape { 9083 var col types.Invitation 9084 destAddr := &col 9085 if err := awsRestjson1_deserializeDocumentInvitation(&destAddr, value); err != nil { 9086 return err 9087 } 9088 col = *destAddr 9089 cv = append(cv, col) 9090 9091 } 9092 *v = cv 9093 return nil 9094} 9095 9096func awsRestjson1_deserializeDocument__listOfJobScopeTerm(v *[]types.JobScopeTerm, value interface{}) error { 9097 if v == nil { 9098 return fmt.Errorf("unexpected nil of type %T", v) 9099 } 9100 if value == nil { 9101 return nil 9102 } 9103 9104 shape, ok := value.([]interface{}) 9105 if !ok { 9106 return fmt.Errorf("unexpected JSON type %v", value) 9107 } 9108 9109 var cv []types.JobScopeTerm 9110 if *v == nil { 9111 cv = []types.JobScopeTerm{} 9112 } else { 9113 cv = *v 9114 } 9115 9116 for _, value := range shape { 9117 var col types.JobScopeTerm 9118 destAddr := &col 9119 if err := awsRestjson1_deserializeDocumentJobScopeTerm(&destAddr, value); err != nil { 9120 return err 9121 } 9122 col = *destAddr 9123 cv = append(cv, col) 9124 9125 } 9126 *v = cv 9127 return nil 9128} 9129 9130func awsRestjson1_deserializeDocument__listOfJobSummary(v *[]types.JobSummary, value interface{}) error { 9131 if v == nil { 9132 return fmt.Errorf("unexpected nil of type %T", v) 9133 } 9134 if value == nil { 9135 return nil 9136 } 9137 9138 shape, ok := value.([]interface{}) 9139 if !ok { 9140 return fmt.Errorf("unexpected JSON type %v", value) 9141 } 9142 9143 var cv []types.JobSummary 9144 if *v == nil { 9145 cv = []types.JobSummary{} 9146 } else { 9147 cv = *v 9148 } 9149 9150 for _, value := range shape { 9151 var col types.JobSummary 9152 destAddr := &col 9153 if err := awsRestjson1_deserializeDocumentJobSummary(&destAddr, value); err != nil { 9154 return err 9155 } 9156 col = *destAddr 9157 cv = append(cv, col) 9158 9159 } 9160 *v = cv 9161 return nil 9162} 9163 9164func awsRestjson1_deserializeDocument__listOfKeyValuePair(v *[]types.KeyValuePair, value interface{}) error { 9165 if v == nil { 9166 return fmt.Errorf("unexpected nil of type %T", v) 9167 } 9168 if value == nil { 9169 return nil 9170 } 9171 9172 shape, ok := value.([]interface{}) 9173 if !ok { 9174 return fmt.Errorf("unexpected JSON type %v", value) 9175 } 9176 9177 var cv []types.KeyValuePair 9178 if *v == nil { 9179 cv = []types.KeyValuePair{} 9180 } else { 9181 cv = *v 9182 } 9183 9184 for _, value := range shape { 9185 var col types.KeyValuePair 9186 destAddr := &col 9187 if err := awsRestjson1_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 9188 return err 9189 } 9190 col = *destAddr 9191 cv = append(cv, col) 9192 9193 } 9194 *v = cv 9195 return nil 9196} 9197 9198func awsRestjson1_deserializeDocument__listOfMember(v *[]types.Member, value interface{}) error { 9199 if v == nil { 9200 return fmt.Errorf("unexpected nil of type %T", v) 9201 } 9202 if value == nil { 9203 return nil 9204 } 9205 9206 shape, ok := value.([]interface{}) 9207 if !ok { 9208 return fmt.Errorf("unexpected JSON type %v", value) 9209 } 9210 9211 var cv []types.Member 9212 if *v == nil { 9213 cv = []types.Member{} 9214 } else { 9215 cv = *v 9216 } 9217 9218 for _, value := range shape { 9219 var col types.Member 9220 destAddr := &col 9221 if err := awsRestjson1_deserializeDocumentMember(&destAddr, value); err != nil { 9222 return err 9223 } 9224 col = *destAddr 9225 cv = append(cv, col) 9226 9227 } 9228 *v = cv 9229 return nil 9230} 9231 9232func awsRestjson1_deserializeDocument__listOfS3BucketDefinitionForJob(v *[]types.S3BucketDefinitionForJob, value interface{}) error { 9233 if v == nil { 9234 return fmt.Errorf("unexpected nil of type %T", v) 9235 } 9236 if value == nil { 9237 return nil 9238 } 9239 9240 shape, ok := value.([]interface{}) 9241 if !ok { 9242 return fmt.Errorf("unexpected JSON type %v", value) 9243 } 9244 9245 var cv []types.S3BucketDefinitionForJob 9246 if *v == nil { 9247 cv = []types.S3BucketDefinitionForJob{} 9248 } else { 9249 cv = *v 9250 } 9251 9252 for _, value := range shape { 9253 var col types.S3BucketDefinitionForJob 9254 destAddr := &col 9255 if err := awsRestjson1_deserializeDocumentS3BucketDefinitionForJob(&destAddr, value); err != nil { 9256 return err 9257 } 9258 col = *destAddr 9259 cv = append(cv, col) 9260 9261 } 9262 *v = cv 9263 return nil 9264} 9265 9266func awsRestjson1_deserializeDocument__listOfTagValuePair(v *[]types.TagValuePair, value interface{}) error { 9267 if v == nil { 9268 return fmt.Errorf("unexpected nil of type %T", v) 9269 } 9270 if value == nil { 9271 return nil 9272 } 9273 9274 shape, ok := value.([]interface{}) 9275 if !ok { 9276 return fmt.Errorf("unexpected JSON type %v", value) 9277 } 9278 9279 var cv []types.TagValuePair 9280 if *v == nil { 9281 cv = []types.TagValuePair{} 9282 } else { 9283 cv = *v 9284 } 9285 9286 for _, value := range shape { 9287 var col types.TagValuePair 9288 destAddr := &col 9289 if err := awsRestjson1_deserializeDocumentTagValuePair(&destAddr, value); err != nil { 9290 return err 9291 } 9292 col = *destAddr 9293 cv = append(cv, col) 9294 9295 } 9296 *v = cv 9297 return nil 9298} 9299 9300func awsRestjson1_deserializeDocument__listOfUnprocessedAccount(v *[]types.UnprocessedAccount, value interface{}) error { 9301 if v == nil { 9302 return fmt.Errorf("unexpected nil of type %T", v) 9303 } 9304 if value == nil { 9305 return nil 9306 } 9307 9308 shape, ok := value.([]interface{}) 9309 if !ok { 9310 return fmt.Errorf("unexpected JSON type %v", value) 9311 } 9312 9313 var cv []types.UnprocessedAccount 9314 if *v == nil { 9315 cv = []types.UnprocessedAccount{} 9316 } else { 9317 cv = *v 9318 } 9319 9320 for _, value := range shape { 9321 var col types.UnprocessedAccount 9322 destAddr := &col 9323 if err := awsRestjson1_deserializeDocumentUnprocessedAccount(&destAddr, value); err != nil { 9324 return err 9325 } 9326 col = *destAddr 9327 cv = append(cv, col) 9328 9329 } 9330 *v = cv 9331 return nil 9332} 9333 9334func awsRestjson1_deserializeDocument__listOfUsageByAccount(v *[]types.UsageByAccount, value interface{}) error { 9335 if v == nil { 9336 return fmt.Errorf("unexpected nil of type %T", v) 9337 } 9338 if value == nil { 9339 return nil 9340 } 9341 9342 shape, ok := value.([]interface{}) 9343 if !ok { 9344 return fmt.Errorf("unexpected JSON type %v", value) 9345 } 9346 9347 var cv []types.UsageByAccount 9348 if *v == nil { 9349 cv = []types.UsageByAccount{} 9350 } else { 9351 cv = *v 9352 } 9353 9354 for _, value := range shape { 9355 var col types.UsageByAccount 9356 destAddr := &col 9357 if err := awsRestjson1_deserializeDocumentUsageByAccount(&destAddr, value); err != nil { 9358 return err 9359 } 9360 col = *destAddr 9361 cv = append(cv, col) 9362 9363 } 9364 *v = cv 9365 return nil 9366} 9367 9368func awsRestjson1_deserializeDocument__listOfUsageRecord(v *[]types.UsageRecord, value interface{}) error { 9369 if v == nil { 9370 return fmt.Errorf("unexpected nil of type %T", v) 9371 } 9372 if value == nil { 9373 return nil 9374 } 9375 9376 shape, ok := value.([]interface{}) 9377 if !ok { 9378 return fmt.Errorf("unexpected JSON type %v", value) 9379 } 9380 9381 var cv []types.UsageRecord 9382 if *v == nil { 9383 cv = []types.UsageRecord{} 9384 } else { 9385 cv = *v 9386 } 9387 9388 for _, value := range shape { 9389 var col types.UsageRecord 9390 destAddr := &col 9391 if err := awsRestjson1_deserializeDocumentUsageRecord(&destAddr, value); err != nil { 9392 return err 9393 } 9394 col = *destAddr 9395 cv = append(cv, col) 9396 9397 } 9398 *v = cv 9399 return nil 9400} 9401 9402func awsRestjson1_deserializeDocument__listOfUsageTotal(v *[]types.UsageTotal, value interface{}) error { 9403 if v == nil { 9404 return fmt.Errorf("unexpected nil of type %T", v) 9405 } 9406 if value == nil { 9407 return nil 9408 } 9409 9410 shape, ok := value.([]interface{}) 9411 if !ok { 9412 return fmt.Errorf("unexpected JSON type %v", value) 9413 } 9414 9415 var cv []types.UsageTotal 9416 if *v == nil { 9417 cv = []types.UsageTotal{} 9418 } else { 9419 cv = *v 9420 } 9421 9422 for _, value := range shape { 9423 var col types.UsageTotal 9424 destAddr := &col 9425 if err := awsRestjson1_deserializeDocumentUsageTotal(&destAddr, value); err != nil { 9426 return err 9427 } 9428 col = *destAddr 9429 cv = append(cv, col) 9430 9431 } 9432 *v = cv 9433 return nil 9434} 9435 9436func awsRestjson1_deserializeDocumentAccessControlList(v **types.AccessControlList, value interface{}) error { 9437 if v == nil { 9438 return fmt.Errorf("unexpected nil of type %T", v) 9439 } 9440 if value == nil { 9441 return nil 9442 } 9443 9444 shape, ok := value.(map[string]interface{}) 9445 if !ok { 9446 return fmt.Errorf("unexpected JSON type %v", value) 9447 } 9448 9449 var sv *types.AccessControlList 9450 if *v == nil { 9451 sv = &types.AccessControlList{} 9452 } else { 9453 sv = *v 9454 } 9455 9456 for key, value := range shape { 9457 switch key { 9458 case "allowsPublicReadAccess": 9459 if value != nil { 9460 jtv, ok := value.(bool) 9461 if !ok { 9462 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9463 } 9464 sv.AllowsPublicReadAccess = jtv 9465 } 9466 9467 case "allowsPublicWriteAccess": 9468 if value != nil { 9469 jtv, ok := value.(bool) 9470 if !ok { 9471 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9472 } 9473 sv.AllowsPublicWriteAccess = jtv 9474 } 9475 9476 default: 9477 _, _ = key, value 9478 9479 } 9480 } 9481 *v = sv 9482 return nil 9483} 9484 9485func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 9486 if v == nil { 9487 return fmt.Errorf("unexpected nil of type %T", v) 9488 } 9489 if value == nil { 9490 return nil 9491 } 9492 9493 shape, ok := value.(map[string]interface{}) 9494 if !ok { 9495 return fmt.Errorf("unexpected JSON type %v", value) 9496 } 9497 9498 var sv *types.AccessDeniedException 9499 if *v == nil { 9500 sv = &types.AccessDeniedException{} 9501 } else { 9502 sv = *v 9503 } 9504 9505 for key, value := range shape { 9506 switch key { 9507 case "message": 9508 if value != nil { 9509 jtv, ok := value.(string) 9510 if !ok { 9511 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9512 } 9513 sv.Message = ptr.String(jtv) 9514 } 9515 9516 default: 9517 _, _ = key, value 9518 9519 } 9520 } 9521 *v = sv 9522 return nil 9523} 9524 9525func awsRestjson1_deserializeDocumentAccountLevelPermissions(v **types.AccountLevelPermissions, value interface{}) error { 9526 if v == nil { 9527 return fmt.Errorf("unexpected nil of type %T", v) 9528 } 9529 if value == nil { 9530 return nil 9531 } 9532 9533 shape, ok := value.(map[string]interface{}) 9534 if !ok { 9535 return fmt.Errorf("unexpected JSON type %v", value) 9536 } 9537 9538 var sv *types.AccountLevelPermissions 9539 if *v == nil { 9540 sv = &types.AccountLevelPermissions{} 9541 } else { 9542 sv = *v 9543 } 9544 9545 for key, value := range shape { 9546 switch key { 9547 case "blockPublicAccess": 9548 if err := awsRestjson1_deserializeDocumentBlockPublicAccess(&sv.BlockPublicAccess, value); err != nil { 9549 return err 9550 } 9551 9552 default: 9553 _, _ = key, value 9554 9555 } 9556 } 9557 *v = sv 9558 return nil 9559} 9560 9561func awsRestjson1_deserializeDocumentAdminAccount(v **types.AdminAccount, value interface{}) error { 9562 if v == nil { 9563 return fmt.Errorf("unexpected nil of type %T", v) 9564 } 9565 if value == nil { 9566 return nil 9567 } 9568 9569 shape, ok := value.(map[string]interface{}) 9570 if !ok { 9571 return fmt.Errorf("unexpected JSON type %v", value) 9572 } 9573 9574 var sv *types.AdminAccount 9575 if *v == nil { 9576 sv = &types.AdminAccount{} 9577 } else { 9578 sv = *v 9579 } 9580 9581 for key, value := range shape { 9582 switch key { 9583 case "accountId": 9584 if value != nil { 9585 jtv, ok := value.(string) 9586 if !ok { 9587 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9588 } 9589 sv.AccountId = ptr.String(jtv) 9590 } 9591 9592 case "status": 9593 if value != nil { 9594 jtv, ok := value.(string) 9595 if !ok { 9596 return fmt.Errorf("expected AdminStatus to be of type string, got %T instead", value) 9597 } 9598 sv.Status = types.AdminStatus(jtv) 9599 } 9600 9601 default: 9602 _, _ = key, value 9603 9604 } 9605 } 9606 *v = sv 9607 return nil 9608} 9609 9610func awsRestjson1_deserializeDocumentApiCallDetails(v **types.ApiCallDetails, value interface{}) error { 9611 if v == nil { 9612 return fmt.Errorf("unexpected nil of type %T", v) 9613 } 9614 if value == nil { 9615 return nil 9616 } 9617 9618 shape, ok := value.(map[string]interface{}) 9619 if !ok { 9620 return fmt.Errorf("unexpected JSON type %v", value) 9621 } 9622 9623 var sv *types.ApiCallDetails 9624 if *v == nil { 9625 sv = &types.ApiCallDetails{} 9626 } else { 9627 sv = *v 9628 } 9629 9630 for key, value := range shape { 9631 switch key { 9632 case "api": 9633 if value != nil { 9634 jtv, ok := value.(string) 9635 if !ok { 9636 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9637 } 9638 sv.Api = ptr.String(jtv) 9639 } 9640 9641 case "apiServiceName": 9642 if value != nil { 9643 jtv, ok := value.(string) 9644 if !ok { 9645 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9646 } 9647 sv.ApiServiceName = ptr.String(jtv) 9648 } 9649 9650 case "firstSeen": 9651 if value != nil { 9652 jtv, ok := value.(string) 9653 if !ok { 9654 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9655 } 9656 t, err := smithytime.ParseDateTime(jtv) 9657 if err != nil { 9658 return err 9659 } 9660 sv.FirstSeen = ptr.Time(t) 9661 } 9662 9663 case "lastSeen": 9664 if value != nil { 9665 jtv, ok := value.(string) 9666 if !ok { 9667 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9668 } 9669 t, err := smithytime.ParseDateTime(jtv) 9670 if err != nil { 9671 return err 9672 } 9673 sv.LastSeen = ptr.Time(t) 9674 } 9675 9676 default: 9677 _, _ = key, value 9678 9679 } 9680 } 9681 *v = sv 9682 return nil 9683} 9684 9685func awsRestjson1_deserializeDocumentAssumedRole(v **types.AssumedRole, value interface{}) error { 9686 if v == nil { 9687 return fmt.Errorf("unexpected nil of type %T", v) 9688 } 9689 if value == nil { 9690 return nil 9691 } 9692 9693 shape, ok := value.(map[string]interface{}) 9694 if !ok { 9695 return fmt.Errorf("unexpected JSON type %v", value) 9696 } 9697 9698 var sv *types.AssumedRole 9699 if *v == nil { 9700 sv = &types.AssumedRole{} 9701 } else { 9702 sv = *v 9703 } 9704 9705 for key, value := range shape { 9706 switch key { 9707 case "accessKeyId": 9708 if value != nil { 9709 jtv, ok := value.(string) 9710 if !ok { 9711 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9712 } 9713 sv.AccessKeyId = ptr.String(jtv) 9714 } 9715 9716 case "accountId": 9717 if value != nil { 9718 jtv, ok := value.(string) 9719 if !ok { 9720 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9721 } 9722 sv.AccountId = ptr.String(jtv) 9723 } 9724 9725 case "arn": 9726 if value != nil { 9727 jtv, ok := value.(string) 9728 if !ok { 9729 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9730 } 9731 sv.Arn = ptr.String(jtv) 9732 } 9733 9734 case "principalId": 9735 if value != nil { 9736 jtv, ok := value.(string) 9737 if !ok { 9738 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9739 } 9740 sv.PrincipalId = ptr.String(jtv) 9741 } 9742 9743 case "sessionContext": 9744 if err := awsRestjson1_deserializeDocumentSessionContext(&sv.SessionContext, value); err != nil { 9745 return err 9746 } 9747 9748 default: 9749 _, _ = key, value 9750 9751 } 9752 } 9753 *v = sv 9754 return nil 9755} 9756 9757func awsRestjson1_deserializeDocumentAwsAccount(v **types.AwsAccount, value interface{}) error { 9758 if v == nil { 9759 return fmt.Errorf("unexpected nil of type %T", v) 9760 } 9761 if value == nil { 9762 return nil 9763 } 9764 9765 shape, ok := value.(map[string]interface{}) 9766 if !ok { 9767 return fmt.Errorf("unexpected JSON type %v", value) 9768 } 9769 9770 var sv *types.AwsAccount 9771 if *v == nil { 9772 sv = &types.AwsAccount{} 9773 } else { 9774 sv = *v 9775 } 9776 9777 for key, value := range shape { 9778 switch key { 9779 case "accountId": 9780 if value != nil { 9781 jtv, ok := value.(string) 9782 if !ok { 9783 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9784 } 9785 sv.AccountId = ptr.String(jtv) 9786 } 9787 9788 case "principalId": 9789 if value != nil { 9790 jtv, ok := value.(string) 9791 if !ok { 9792 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9793 } 9794 sv.PrincipalId = ptr.String(jtv) 9795 } 9796 9797 default: 9798 _, _ = key, value 9799 9800 } 9801 } 9802 *v = sv 9803 return nil 9804} 9805 9806func awsRestjson1_deserializeDocumentAwsService(v **types.AwsService, value interface{}) error { 9807 if v == nil { 9808 return fmt.Errorf("unexpected nil of type %T", v) 9809 } 9810 if value == nil { 9811 return nil 9812 } 9813 9814 shape, ok := value.(map[string]interface{}) 9815 if !ok { 9816 return fmt.Errorf("unexpected JSON type %v", value) 9817 } 9818 9819 var sv *types.AwsService 9820 if *v == nil { 9821 sv = &types.AwsService{} 9822 } else { 9823 sv = *v 9824 } 9825 9826 for key, value := range shape { 9827 switch key { 9828 case "invokedBy": 9829 if value != nil { 9830 jtv, ok := value.(string) 9831 if !ok { 9832 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9833 } 9834 sv.InvokedBy = ptr.String(jtv) 9835 } 9836 9837 default: 9838 _, _ = key, value 9839 9840 } 9841 } 9842 *v = sv 9843 return nil 9844} 9845 9846func awsRestjson1_deserializeDocumentBatchGetCustomDataIdentifierSummary(v **types.BatchGetCustomDataIdentifierSummary, value interface{}) error { 9847 if v == nil { 9848 return fmt.Errorf("unexpected nil of type %T", v) 9849 } 9850 if value == nil { 9851 return nil 9852 } 9853 9854 shape, ok := value.(map[string]interface{}) 9855 if !ok { 9856 return fmt.Errorf("unexpected JSON type %v", value) 9857 } 9858 9859 var sv *types.BatchGetCustomDataIdentifierSummary 9860 if *v == nil { 9861 sv = &types.BatchGetCustomDataIdentifierSummary{} 9862 } else { 9863 sv = *v 9864 } 9865 9866 for key, value := range shape { 9867 switch key { 9868 case "arn": 9869 if value != nil { 9870 jtv, ok := value.(string) 9871 if !ok { 9872 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9873 } 9874 sv.Arn = ptr.String(jtv) 9875 } 9876 9877 case "createdAt": 9878 if value != nil { 9879 jtv, ok := value.(string) 9880 if !ok { 9881 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 9882 } 9883 t, err := smithytime.ParseDateTime(jtv) 9884 if err != nil { 9885 return err 9886 } 9887 sv.CreatedAt = ptr.Time(t) 9888 } 9889 9890 case "deleted": 9891 if value != nil { 9892 jtv, ok := value.(bool) 9893 if !ok { 9894 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9895 } 9896 sv.Deleted = jtv 9897 } 9898 9899 case "description": 9900 if value != nil { 9901 jtv, ok := value.(string) 9902 if !ok { 9903 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9904 } 9905 sv.Description = ptr.String(jtv) 9906 } 9907 9908 case "id": 9909 if value != nil { 9910 jtv, ok := value.(string) 9911 if !ok { 9912 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9913 } 9914 sv.Id = ptr.String(jtv) 9915 } 9916 9917 case "name": 9918 if value != nil { 9919 jtv, ok := value.(string) 9920 if !ok { 9921 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9922 } 9923 sv.Name = ptr.String(jtv) 9924 } 9925 9926 default: 9927 _, _ = key, value 9928 9929 } 9930 } 9931 *v = sv 9932 return nil 9933} 9934 9935func awsRestjson1_deserializeDocumentBlockPublicAccess(v **types.BlockPublicAccess, value interface{}) error { 9936 if v == nil { 9937 return fmt.Errorf("unexpected nil of type %T", v) 9938 } 9939 if value == nil { 9940 return nil 9941 } 9942 9943 shape, ok := value.(map[string]interface{}) 9944 if !ok { 9945 return fmt.Errorf("unexpected JSON type %v", value) 9946 } 9947 9948 var sv *types.BlockPublicAccess 9949 if *v == nil { 9950 sv = &types.BlockPublicAccess{} 9951 } else { 9952 sv = *v 9953 } 9954 9955 for key, value := range shape { 9956 switch key { 9957 case "blockPublicAcls": 9958 if value != nil { 9959 jtv, ok := value.(bool) 9960 if !ok { 9961 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9962 } 9963 sv.BlockPublicAcls = jtv 9964 } 9965 9966 case "blockPublicPolicy": 9967 if value != nil { 9968 jtv, ok := value.(bool) 9969 if !ok { 9970 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9971 } 9972 sv.BlockPublicPolicy = jtv 9973 } 9974 9975 case "ignorePublicAcls": 9976 if value != nil { 9977 jtv, ok := value.(bool) 9978 if !ok { 9979 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9980 } 9981 sv.IgnorePublicAcls = jtv 9982 } 9983 9984 case "restrictPublicBuckets": 9985 if value != nil { 9986 jtv, ok := value.(bool) 9987 if !ok { 9988 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 9989 } 9990 sv.RestrictPublicBuckets = jtv 9991 } 9992 9993 default: 9994 _, _ = key, value 9995 9996 } 9997 } 9998 *v = sv 9999 return nil 10000} 10001 10002func awsRestjson1_deserializeDocumentBucketCountByEffectivePermission(v **types.BucketCountByEffectivePermission, value interface{}) error { 10003 if v == nil { 10004 return fmt.Errorf("unexpected nil of type %T", v) 10005 } 10006 if value == nil { 10007 return nil 10008 } 10009 10010 shape, ok := value.(map[string]interface{}) 10011 if !ok { 10012 return fmt.Errorf("unexpected JSON type %v", value) 10013 } 10014 10015 var sv *types.BucketCountByEffectivePermission 10016 if *v == nil { 10017 sv = &types.BucketCountByEffectivePermission{} 10018 } else { 10019 sv = *v 10020 } 10021 10022 for key, value := range shape { 10023 switch key { 10024 case "publiclyAccessible": 10025 if value != nil { 10026 jtv, ok := value.(json.Number) 10027 if !ok { 10028 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10029 } 10030 i64, err := jtv.Int64() 10031 if err != nil { 10032 return err 10033 } 10034 sv.PubliclyAccessible = i64 10035 } 10036 10037 case "publiclyReadable": 10038 if value != nil { 10039 jtv, ok := value.(json.Number) 10040 if !ok { 10041 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10042 } 10043 i64, err := jtv.Int64() 10044 if err != nil { 10045 return err 10046 } 10047 sv.PubliclyReadable = i64 10048 } 10049 10050 case "publiclyWritable": 10051 if value != nil { 10052 jtv, ok := value.(json.Number) 10053 if !ok { 10054 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10055 } 10056 i64, err := jtv.Int64() 10057 if err != nil { 10058 return err 10059 } 10060 sv.PubliclyWritable = i64 10061 } 10062 10063 case "unknown": 10064 if value != nil { 10065 jtv, ok := value.(json.Number) 10066 if !ok { 10067 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10068 } 10069 i64, err := jtv.Int64() 10070 if err != nil { 10071 return err 10072 } 10073 sv.Unknown = i64 10074 } 10075 10076 default: 10077 _, _ = key, value 10078 10079 } 10080 } 10081 *v = sv 10082 return nil 10083} 10084 10085func awsRestjson1_deserializeDocumentBucketCountByEncryptionType(v **types.BucketCountByEncryptionType, value interface{}) error { 10086 if v == nil { 10087 return fmt.Errorf("unexpected nil of type %T", v) 10088 } 10089 if value == nil { 10090 return nil 10091 } 10092 10093 shape, ok := value.(map[string]interface{}) 10094 if !ok { 10095 return fmt.Errorf("unexpected JSON type %v", value) 10096 } 10097 10098 var sv *types.BucketCountByEncryptionType 10099 if *v == nil { 10100 sv = &types.BucketCountByEncryptionType{} 10101 } else { 10102 sv = *v 10103 } 10104 10105 for key, value := range shape { 10106 switch key { 10107 case "kmsManaged": 10108 if value != nil { 10109 jtv, ok := value.(json.Number) 10110 if !ok { 10111 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10112 } 10113 i64, err := jtv.Int64() 10114 if err != nil { 10115 return err 10116 } 10117 sv.KmsManaged = i64 10118 } 10119 10120 case "s3Managed": 10121 if value != nil { 10122 jtv, ok := value.(json.Number) 10123 if !ok { 10124 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10125 } 10126 i64, err := jtv.Int64() 10127 if err != nil { 10128 return err 10129 } 10130 sv.S3Managed = i64 10131 } 10132 10133 case "unencrypted": 10134 if value != nil { 10135 jtv, ok := value.(json.Number) 10136 if !ok { 10137 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10138 } 10139 i64, err := jtv.Int64() 10140 if err != nil { 10141 return err 10142 } 10143 sv.Unencrypted = i64 10144 } 10145 10146 case "unknown": 10147 if value != nil { 10148 jtv, ok := value.(json.Number) 10149 if !ok { 10150 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10151 } 10152 i64, err := jtv.Int64() 10153 if err != nil { 10154 return err 10155 } 10156 sv.Unknown = i64 10157 } 10158 10159 default: 10160 _, _ = key, value 10161 10162 } 10163 } 10164 *v = sv 10165 return nil 10166} 10167 10168func awsRestjson1_deserializeDocumentBucketCountBySharedAccessType(v **types.BucketCountBySharedAccessType, value interface{}) error { 10169 if v == nil { 10170 return fmt.Errorf("unexpected nil of type %T", v) 10171 } 10172 if value == nil { 10173 return nil 10174 } 10175 10176 shape, ok := value.(map[string]interface{}) 10177 if !ok { 10178 return fmt.Errorf("unexpected JSON type %v", value) 10179 } 10180 10181 var sv *types.BucketCountBySharedAccessType 10182 if *v == nil { 10183 sv = &types.BucketCountBySharedAccessType{} 10184 } else { 10185 sv = *v 10186 } 10187 10188 for key, value := range shape { 10189 switch key { 10190 case "external": 10191 if value != nil { 10192 jtv, ok := value.(json.Number) 10193 if !ok { 10194 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10195 } 10196 i64, err := jtv.Int64() 10197 if err != nil { 10198 return err 10199 } 10200 sv.External = i64 10201 } 10202 10203 case "internal": 10204 if value != nil { 10205 jtv, ok := value.(json.Number) 10206 if !ok { 10207 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10208 } 10209 i64, err := jtv.Int64() 10210 if err != nil { 10211 return err 10212 } 10213 sv.Internal = i64 10214 } 10215 10216 case "notShared": 10217 if value != nil { 10218 jtv, ok := value.(json.Number) 10219 if !ok { 10220 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10221 } 10222 i64, err := jtv.Int64() 10223 if err != nil { 10224 return err 10225 } 10226 sv.NotShared = i64 10227 } 10228 10229 case "unknown": 10230 if value != nil { 10231 jtv, ok := value.(json.Number) 10232 if !ok { 10233 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10234 } 10235 i64, err := jtv.Int64() 10236 if err != nil { 10237 return err 10238 } 10239 sv.Unknown = i64 10240 } 10241 10242 default: 10243 _, _ = key, value 10244 10245 } 10246 } 10247 *v = sv 10248 return nil 10249} 10250 10251func awsRestjson1_deserializeDocumentBucketCountPolicyAllowsUnencryptedObjectUploads(v **types.BucketCountPolicyAllowsUnencryptedObjectUploads, value interface{}) error { 10252 if v == nil { 10253 return fmt.Errorf("unexpected nil of type %T", v) 10254 } 10255 if value == nil { 10256 return nil 10257 } 10258 10259 shape, ok := value.(map[string]interface{}) 10260 if !ok { 10261 return fmt.Errorf("unexpected JSON type %v", value) 10262 } 10263 10264 var sv *types.BucketCountPolicyAllowsUnencryptedObjectUploads 10265 if *v == nil { 10266 sv = &types.BucketCountPolicyAllowsUnencryptedObjectUploads{} 10267 } else { 10268 sv = *v 10269 } 10270 10271 for key, value := range shape { 10272 switch key { 10273 case "allowsUnencryptedObjectUploads": 10274 if value != nil { 10275 jtv, ok := value.(json.Number) 10276 if !ok { 10277 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10278 } 10279 i64, err := jtv.Int64() 10280 if err != nil { 10281 return err 10282 } 10283 sv.AllowsUnencryptedObjectUploads = i64 10284 } 10285 10286 case "deniesUnencryptedObjectUploads": 10287 if value != nil { 10288 jtv, ok := value.(json.Number) 10289 if !ok { 10290 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10291 } 10292 i64, err := jtv.Int64() 10293 if err != nil { 10294 return err 10295 } 10296 sv.DeniesUnencryptedObjectUploads = i64 10297 } 10298 10299 case "unknown": 10300 if value != nil { 10301 jtv, ok := value.(json.Number) 10302 if !ok { 10303 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10304 } 10305 i64, err := jtv.Int64() 10306 if err != nil { 10307 return err 10308 } 10309 sv.Unknown = i64 10310 } 10311 10312 default: 10313 _, _ = key, value 10314 10315 } 10316 } 10317 *v = sv 10318 return nil 10319} 10320 10321func awsRestjson1_deserializeDocumentBucketLevelPermissions(v **types.BucketLevelPermissions, value interface{}) error { 10322 if v == nil { 10323 return fmt.Errorf("unexpected nil of type %T", v) 10324 } 10325 if value == nil { 10326 return nil 10327 } 10328 10329 shape, ok := value.(map[string]interface{}) 10330 if !ok { 10331 return fmt.Errorf("unexpected JSON type %v", value) 10332 } 10333 10334 var sv *types.BucketLevelPermissions 10335 if *v == nil { 10336 sv = &types.BucketLevelPermissions{} 10337 } else { 10338 sv = *v 10339 } 10340 10341 for key, value := range shape { 10342 switch key { 10343 case "accessControlList": 10344 if err := awsRestjson1_deserializeDocumentAccessControlList(&sv.AccessControlList, value); err != nil { 10345 return err 10346 } 10347 10348 case "blockPublicAccess": 10349 if err := awsRestjson1_deserializeDocumentBlockPublicAccess(&sv.BlockPublicAccess, value); err != nil { 10350 return err 10351 } 10352 10353 case "bucketPolicy": 10354 if err := awsRestjson1_deserializeDocumentBucketPolicy(&sv.BucketPolicy, value); err != nil { 10355 return err 10356 } 10357 10358 default: 10359 _, _ = key, value 10360 10361 } 10362 } 10363 *v = sv 10364 return nil 10365} 10366 10367func awsRestjson1_deserializeDocumentBucketMetadata(v **types.BucketMetadata, value interface{}) error { 10368 if v == nil { 10369 return fmt.Errorf("unexpected nil of type %T", v) 10370 } 10371 if value == nil { 10372 return nil 10373 } 10374 10375 shape, ok := value.(map[string]interface{}) 10376 if !ok { 10377 return fmt.Errorf("unexpected JSON type %v", value) 10378 } 10379 10380 var sv *types.BucketMetadata 10381 if *v == nil { 10382 sv = &types.BucketMetadata{} 10383 } else { 10384 sv = *v 10385 } 10386 10387 for key, value := range shape { 10388 switch key { 10389 case "accountId": 10390 if value != nil { 10391 jtv, ok := value.(string) 10392 if !ok { 10393 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10394 } 10395 sv.AccountId = ptr.String(jtv) 10396 } 10397 10398 case "allowsUnencryptedObjectUploads": 10399 if value != nil { 10400 jtv, ok := value.(string) 10401 if !ok { 10402 return fmt.Errorf("expected AllowsUnencryptedObjectUploads to be of type string, got %T instead", value) 10403 } 10404 sv.AllowsUnencryptedObjectUploads = types.AllowsUnencryptedObjectUploads(jtv) 10405 } 10406 10407 case "bucketArn": 10408 if value != nil { 10409 jtv, ok := value.(string) 10410 if !ok { 10411 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10412 } 10413 sv.BucketArn = ptr.String(jtv) 10414 } 10415 10416 case "bucketCreatedAt": 10417 if value != nil { 10418 jtv, ok := value.(string) 10419 if !ok { 10420 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 10421 } 10422 t, err := smithytime.ParseDateTime(jtv) 10423 if err != nil { 10424 return err 10425 } 10426 sv.BucketCreatedAt = ptr.Time(t) 10427 } 10428 10429 case "bucketName": 10430 if value != nil { 10431 jtv, ok := value.(string) 10432 if !ok { 10433 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10434 } 10435 sv.BucketName = ptr.String(jtv) 10436 } 10437 10438 case "classifiableObjectCount": 10439 if value != nil { 10440 jtv, ok := value.(json.Number) 10441 if !ok { 10442 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10443 } 10444 i64, err := jtv.Int64() 10445 if err != nil { 10446 return err 10447 } 10448 sv.ClassifiableObjectCount = i64 10449 } 10450 10451 case "classifiableSizeInBytes": 10452 if value != nil { 10453 jtv, ok := value.(json.Number) 10454 if !ok { 10455 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10456 } 10457 i64, err := jtv.Int64() 10458 if err != nil { 10459 return err 10460 } 10461 sv.ClassifiableSizeInBytes = i64 10462 } 10463 10464 case "jobDetails": 10465 if err := awsRestjson1_deserializeDocumentJobDetails(&sv.JobDetails, value); err != nil { 10466 return err 10467 } 10468 10469 case "lastUpdated": 10470 if value != nil { 10471 jtv, ok := value.(string) 10472 if !ok { 10473 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 10474 } 10475 t, err := smithytime.ParseDateTime(jtv) 10476 if err != nil { 10477 return err 10478 } 10479 sv.LastUpdated = ptr.Time(t) 10480 } 10481 10482 case "objectCount": 10483 if value != nil { 10484 jtv, ok := value.(json.Number) 10485 if !ok { 10486 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10487 } 10488 i64, err := jtv.Int64() 10489 if err != nil { 10490 return err 10491 } 10492 sv.ObjectCount = i64 10493 } 10494 10495 case "objectCountByEncryptionType": 10496 if err := awsRestjson1_deserializeDocumentObjectCountByEncryptionType(&sv.ObjectCountByEncryptionType, value); err != nil { 10497 return err 10498 } 10499 10500 case "publicAccess": 10501 if err := awsRestjson1_deserializeDocumentBucketPublicAccess(&sv.PublicAccess, value); err != nil { 10502 return err 10503 } 10504 10505 case "region": 10506 if value != nil { 10507 jtv, ok := value.(string) 10508 if !ok { 10509 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10510 } 10511 sv.Region = ptr.String(jtv) 10512 } 10513 10514 case "replicationDetails": 10515 if err := awsRestjson1_deserializeDocumentReplicationDetails(&sv.ReplicationDetails, value); err != nil { 10516 return err 10517 } 10518 10519 case "serverSideEncryption": 10520 if err := awsRestjson1_deserializeDocumentBucketServerSideEncryption(&sv.ServerSideEncryption, value); err != nil { 10521 return err 10522 } 10523 10524 case "sharedAccess": 10525 if value != nil { 10526 jtv, ok := value.(string) 10527 if !ok { 10528 return fmt.Errorf("expected SharedAccess to be of type string, got %T instead", value) 10529 } 10530 sv.SharedAccess = types.SharedAccess(jtv) 10531 } 10532 10533 case "sizeInBytes": 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.SizeInBytes = i64 10544 } 10545 10546 case "sizeInBytesCompressed": 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.SizeInBytesCompressed = i64 10557 } 10558 10559 case "tags": 10560 if err := awsRestjson1_deserializeDocument__listOfKeyValuePair(&sv.Tags, value); err != nil { 10561 return err 10562 } 10563 10564 case "unclassifiableObjectCount": 10565 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectCount, value); err != nil { 10566 return err 10567 } 10568 10569 case "unclassifiableObjectSizeInBytes": 10570 if err := awsRestjson1_deserializeDocumentObjectLevelStatistics(&sv.UnclassifiableObjectSizeInBytes, value); err != nil { 10571 return err 10572 } 10573 10574 case "versioning": 10575 if value != nil { 10576 jtv, ok := value.(bool) 10577 if !ok { 10578 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 10579 } 10580 sv.Versioning = jtv 10581 } 10582 10583 default: 10584 _, _ = key, value 10585 10586 } 10587 } 10588 *v = sv 10589 return nil 10590} 10591 10592func awsRestjson1_deserializeDocumentBucketPermissionConfiguration(v **types.BucketPermissionConfiguration, value interface{}) error { 10593 if v == nil { 10594 return fmt.Errorf("unexpected nil of type %T", v) 10595 } 10596 if value == nil { 10597 return nil 10598 } 10599 10600 shape, ok := value.(map[string]interface{}) 10601 if !ok { 10602 return fmt.Errorf("unexpected JSON type %v", value) 10603 } 10604 10605 var sv *types.BucketPermissionConfiguration 10606 if *v == nil { 10607 sv = &types.BucketPermissionConfiguration{} 10608 } else { 10609 sv = *v 10610 } 10611 10612 for key, value := range shape { 10613 switch key { 10614 case "accountLevelPermissions": 10615 if err := awsRestjson1_deserializeDocumentAccountLevelPermissions(&sv.AccountLevelPermissions, value); err != nil { 10616 return err 10617 } 10618 10619 case "bucketLevelPermissions": 10620 if err := awsRestjson1_deserializeDocumentBucketLevelPermissions(&sv.BucketLevelPermissions, value); err != nil { 10621 return err 10622 } 10623 10624 default: 10625 _, _ = key, value 10626 10627 } 10628 } 10629 *v = sv 10630 return nil 10631} 10632 10633func awsRestjson1_deserializeDocumentBucketPolicy(v **types.BucketPolicy, value interface{}) error { 10634 if v == nil { 10635 return fmt.Errorf("unexpected nil of type %T", v) 10636 } 10637 if value == nil { 10638 return nil 10639 } 10640 10641 shape, ok := value.(map[string]interface{}) 10642 if !ok { 10643 return fmt.Errorf("unexpected JSON type %v", value) 10644 } 10645 10646 var sv *types.BucketPolicy 10647 if *v == nil { 10648 sv = &types.BucketPolicy{} 10649 } else { 10650 sv = *v 10651 } 10652 10653 for key, value := range shape { 10654 switch key { 10655 case "allowsPublicReadAccess": 10656 if value != nil { 10657 jtv, ok := value.(bool) 10658 if !ok { 10659 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 10660 } 10661 sv.AllowsPublicReadAccess = jtv 10662 } 10663 10664 case "allowsPublicWriteAccess": 10665 if value != nil { 10666 jtv, ok := value.(bool) 10667 if !ok { 10668 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 10669 } 10670 sv.AllowsPublicWriteAccess = jtv 10671 } 10672 10673 default: 10674 _, _ = key, value 10675 10676 } 10677 } 10678 *v = sv 10679 return nil 10680} 10681 10682func awsRestjson1_deserializeDocumentBucketPublicAccess(v **types.BucketPublicAccess, value interface{}) error { 10683 if v == nil { 10684 return fmt.Errorf("unexpected nil of type %T", v) 10685 } 10686 if value == nil { 10687 return nil 10688 } 10689 10690 shape, ok := value.(map[string]interface{}) 10691 if !ok { 10692 return fmt.Errorf("unexpected JSON type %v", value) 10693 } 10694 10695 var sv *types.BucketPublicAccess 10696 if *v == nil { 10697 sv = &types.BucketPublicAccess{} 10698 } else { 10699 sv = *v 10700 } 10701 10702 for key, value := range shape { 10703 switch key { 10704 case "effectivePermission": 10705 if value != nil { 10706 jtv, ok := value.(string) 10707 if !ok { 10708 return fmt.Errorf("expected EffectivePermission to be of type string, got %T instead", value) 10709 } 10710 sv.EffectivePermission = types.EffectivePermission(jtv) 10711 } 10712 10713 case "permissionConfiguration": 10714 if err := awsRestjson1_deserializeDocumentBucketPermissionConfiguration(&sv.PermissionConfiguration, value); err != nil { 10715 return err 10716 } 10717 10718 default: 10719 _, _ = key, value 10720 10721 } 10722 } 10723 *v = sv 10724 return nil 10725} 10726 10727func awsRestjson1_deserializeDocumentBucketServerSideEncryption(v **types.BucketServerSideEncryption, value interface{}) error { 10728 if v == nil { 10729 return fmt.Errorf("unexpected nil of type %T", v) 10730 } 10731 if value == nil { 10732 return nil 10733 } 10734 10735 shape, ok := value.(map[string]interface{}) 10736 if !ok { 10737 return fmt.Errorf("unexpected JSON type %v", value) 10738 } 10739 10740 var sv *types.BucketServerSideEncryption 10741 if *v == nil { 10742 sv = &types.BucketServerSideEncryption{} 10743 } else { 10744 sv = *v 10745 } 10746 10747 for key, value := range shape { 10748 switch key { 10749 case "kmsMasterKeyId": 10750 if value != nil { 10751 jtv, ok := value.(string) 10752 if !ok { 10753 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10754 } 10755 sv.KmsMasterKeyId = ptr.String(jtv) 10756 } 10757 10758 case "type": 10759 if value != nil { 10760 jtv, ok := value.(string) 10761 if !ok { 10762 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 10763 } 10764 sv.Type = types.Type(jtv) 10765 } 10766 10767 default: 10768 _, _ = key, value 10769 10770 } 10771 } 10772 *v = sv 10773 return nil 10774} 10775 10776func awsRestjson1_deserializeDocumentCell(v **types.Cell, value interface{}) error { 10777 if v == nil { 10778 return fmt.Errorf("unexpected nil of type %T", v) 10779 } 10780 if value == nil { 10781 return nil 10782 } 10783 10784 shape, ok := value.(map[string]interface{}) 10785 if !ok { 10786 return fmt.Errorf("unexpected JSON type %v", value) 10787 } 10788 10789 var sv *types.Cell 10790 if *v == nil { 10791 sv = &types.Cell{} 10792 } else { 10793 sv = *v 10794 } 10795 10796 for key, value := range shape { 10797 switch key { 10798 case "cellReference": 10799 if value != nil { 10800 jtv, ok := value.(string) 10801 if !ok { 10802 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10803 } 10804 sv.CellReference = ptr.String(jtv) 10805 } 10806 10807 case "column": 10808 if value != nil { 10809 jtv, ok := value.(json.Number) 10810 if !ok { 10811 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10812 } 10813 i64, err := jtv.Int64() 10814 if err != nil { 10815 return err 10816 } 10817 sv.Column = i64 10818 } 10819 10820 case "columnName": 10821 if value != nil { 10822 jtv, ok := value.(string) 10823 if !ok { 10824 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10825 } 10826 sv.ColumnName = ptr.String(jtv) 10827 } 10828 10829 case "row": 10830 if value != nil { 10831 jtv, ok := value.(json.Number) 10832 if !ok { 10833 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 10834 } 10835 i64, err := jtv.Int64() 10836 if err != nil { 10837 return err 10838 } 10839 sv.Row = i64 10840 } 10841 10842 default: 10843 _, _ = key, value 10844 10845 } 10846 } 10847 *v = sv 10848 return nil 10849} 10850 10851func awsRestjson1_deserializeDocumentCells(v *[]types.Cell, value interface{}) error { 10852 if v == nil { 10853 return fmt.Errorf("unexpected nil of type %T", v) 10854 } 10855 if value == nil { 10856 return nil 10857 } 10858 10859 shape, ok := value.([]interface{}) 10860 if !ok { 10861 return fmt.Errorf("unexpected JSON type %v", value) 10862 } 10863 10864 var cv []types.Cell 10865 if *v == nil { 10866 cv = []types.Cell{} 10867 } else { 10868 cv = *v 10869 } 10870 10871 for _, value := range shape { 10872 var col types.Cell 10873 destAddr := &col 10874 if err := awsRestjson1_deserializeDocumentCell(&destAddr, value); err != nil { 10875 return err 10876 } 10877 col = *destAddr 10878 cv = append(cv, col) 10879 10880 } 10881 *v = cv 10882 return nil 10883} 10884 10885func awsRestjson1_deserializeDocumentClassificationDetails(v **types.ClassificationDetails, value interface{}) error { 10886 if v == nil { 10887 return fmt.Errorf("unexpected nil of type %T", v) 10888 } 10889 if value == nil { 10890 return nil 10891 } 10892 10893 shape, ok := value.(map[string]interface{}) 10894 if !ok { 10895 return fmt.Errorf("unexpected JSON type %v", value) 10896 } 10897 10898 var sv *types.ClassificationDetails 10899 if *v == nil { 10900 sv = &types.ClassificationDetails{} 10901 } else { 10902 sv = *v 10903 } 10904 10905 for key, value := range shape { 10906 switch key { 10907 case "detailedResultsLocation": 10908 if value != nil { 10909 jtv, ok := value.(string) 10910 if !ok { 10911 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10912 } 10913 sv.DetailedResultsLocation = ptr.String(jtv) 10914 } 10915 10916 case "jobArn": 10917 if value != nil { 10918 jtv, ok := value.(string) 10919 if !ok { 10920 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10921 } 10922 sv.JobArn = ptr.String(jtv) 10923 } 10924 10925 case "jobId": 10926 if value != nil { 10927 jtv, ok := value.(string) 10928 if !ok { 10929 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10930 } 10931 sv.JobId = ptr.String(jtv) 10932 } 10933 10934 case "result": 10935 if err := awsRestjson1_deserializeDocumentClassificationResult(&sv.Result, value); err != nil { 10936 return err 10937 } 10938 10939 default: 10940 _, _ = key, value 10941 10942 } 10943 } 10944 *v = sv 10945 return nil 10946} 10947 10948func awsRestjson1_deserializeDocumentClassificationExportConfiguration(v **types.ClassificationExportConfiguration, value interface{}) error { 10949 if v == nil { 10950 return fmt.Errorf("unexpected nil of type %T", v) 10951 } 10952 if value == nil { 10953 return nil 10954 } 10955 10956 shape, ok := value.(map[string]interface{}) 10957 if !ok { 10958 return fmt.Errorf("unexpected JSON type %v", value) 10959 } 10960 10961 var sv *types.ClassificationExportConfiguration 10962 if *v == nil { 10963 sv = &types.ClassificationExportConfiguration{} 10964 } else { 10965 sv = *v 10966 } 10967 10968 for key, value := range shape { 10969 switch key { 10970 case "s3Destination": 10971 if err := awsRestjson1_deserializeDocumentS3Destination(&sv.S3Destination, value); err != nil { 10972 return err 10973 } 10974 10975 default: 10976 _, _ = key, value 10977 10978 } 10979 } 10980 *v = sv 10981 return nil 10982} 10983 10984func awsRestjson1_deserializeDocumentClassificationResult(v **types.ClassificationResult, value interface{}) error { 10985 if v == nil { 10986 return fmt.Errorf("unexpected nil of type %T", v) 10987 } 10988 if value == nil { 10989 return nil 10990 } 10991 10992 shape, ok := value.(map[string]interface{}) 10993 if !ok { 10994 return fmt.Errorf("unexpected JSON type %v", value) 10995 } 10996 10997 var sv *types.ClassificationResult 10998 if *v == nil { 10999 sv = &types.ClassificationResult{} 11000 } else { 11001 sv = *v 11002 } 11003 11004 for key, value := range shape { 11005 switch key { 11006 case "additionalOccurrences": 11007 if value != nil { 11008 jtv, ok := value.(bool) 11009 if !ok { 11010 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 11011 } 11012 sv.AdditionalOccurrences = jtv 11013 } 11014 11015 case "customDataIdentifiers": 11016 if err := awsRestjson1_deserializeDocumentCustomDataIdentifiers(&sv.CustomDataIdentifiers, value); err != nil { 11017 return err 11018 } 11019 11020 case "mimeType": 11021 if value != nil { 11022 jtv, ok := value.(string) 11023 if !ok { 11024 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11025 } 11026 sv.MimeType = ptr.String(jtv) 11027 } 11028 11029 case "sensitiveData": 11030 if err := awsRestjson1_deserializeDocumentSensitiveData(&sv.SensitiveData, value); err != nil { 11031 return err 11032 } 11033 11034 case "sizeClassified": 11035 if value != nil { 11036 jtv, ok := value.(json.Number) 11037 if !ok { 11038 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11039 } 11040 i64, err := jtv.Int64() 11041 if err != nil { 11042 return err 11043 } 11044 sv.SizeClassified = i64 11045 } 11046 11047 case "status": 11048 if err := awsRestjson1_deserializeDocumentClassificationResultStatus(&sv.Status, value); err != nil { 11049 return err 11050 } 11051 11052 default: 11053 _, _ = key, value 11054 11055 } 11056 } 11057 *v = sv 11058 return nil 11059} 11060 11061func awsRestjson1_deserializeDocumentClassificationResultStatus(v **types.ClassificationResultStatus, value interface{}) error { 11062 if v == nil { 11063 return fmt.Errorf("unexpected nil of type %T", v) 11064 } 11065 if value == nil { 11066 return nil 11067 } 11068 11069 shape, ok := value.(map[string]interface{}) 11070 if !ok { 11071 return fmt.Errorf("unexpected JSON type %v", value) 11072 } 11073 11074 var sv *types.ClassificationResultStatus 11075 if *v == nil { 11076 sv = &types.ClassificationResultStatus{} 11077 } else { 11078 sv = *v 11079 } 11080 11081 for key, value := range shape { 11082 switch key { 11083 case "code": 11084 if value != nil { 11085 jtv, ok := value.(string) 11086 if !ok { 11087 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11088 } 11089 sv.Code = ptr.String(jtv) 11090 } 11091 11092 case "reason": 11093 if value != nil { 11094 jtv, ok := value.(string) 11095 if !ok { 11096 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11097 } 11098 sv.Reason = ptr.String(jtv) 11099 } 11100 11101 default: 11102 _, _ = key, value 11103 11104 } 11105 } 11106 *v = sv 11107 return nil 11108} 11109 11110func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 11111 if v == nil { 11112 return fmt.Errorf("unexpected nil of type %T", v) 11113 } 11114 if value == nil { 11115 return nil 11116 } 11117 11118 shape, ok := value.(map[string]interface{}) 11119 if !ok { 11120 return fmt.Errorf("unexpected JSON type %v", value) 11121 } 11122 11123 var sv *types.ConflictException 11124 if *v == nil { 11125 sv = &types.ConflictException{} 11126 } else { 11127 sv = *v 11128 } 11129 11130 for key, value := range shape { 11131 switch key { 11132 case "message": 11133 if value != nil { 11134 jtv, ok := value.(string) 11135 if !ok { 11136 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11137 } 11138 sv.Message = ptr.String(jtv) 11139 } 11140 11141 default: 11142 _, _ = key, value 11143 11144 } 11145 } 11146 *v = sv 11147 return nil 11148} 11149 11150func awsRestjson1_deserializeDocumentCriterion(v *map[string]types.CriterionAdditionalProperties, value interface{}) error { 11151 if v == nil { 11152 return fmt.Errorf("unexpected nil of type %T", v) 11153 } 11154 if value == nil { 11155 return nil 11156 } 11157 11158 shape, ok := value.(map[string]interface{}) 11159 if !ok { 11160 return fmt.Errorf("unexpected JSON type %v", value) 11161 } 11162 11163 var mv map[string]types.CriterionAdditionalProperties 11164 if *v == nil { 11165 mv = map[string]types.CriterionAdditionalProperties{} 11166 } else { 11167 mv = *v 11168 } 11169 11170 for key, value := range shape { 11171 var parsedVal types.CriterionAdditionalProperties 11172 mapVar := parsedVal 11173 destAddr := &mapVar 11174 if err := awsRestjson1_deserializeDocumentCriterionAdditionalProperties(&destAddr, value); err != nil { 11175 return err 11176 } 11177 parsedVal = *destAddr 11178 mv[key] = parsedVal 11179 11180 } 11181 *v = mv 11182 return nil 11183} 11184 11185func awsRestjson1_deserializeDocumentCriterionAdditionalProperties(v **types.CriterionAdditionalProperties, value interface{}) error { 11186 if v == nil { 11187 return fmt.Errorf("unexpected nil of type %T", v) 11188 } 11189 if value == nil { 11190 return nil 11191 } 11192 11193 shape, ok := value.(map[string]interface{}) 11194 if !ok { 11195 return fmt.Errorf("unexpected JSON type %v", value) 11196 } 11197 11198 var sv *types.CriterionAdditionalProperties 11199 if *v == nil { 11200 sv = &types.CriterionAdditionalProperties{} 11201 } else { 11202 sv = *v 11203 } 11204 11205 for key, value := range shape { 11206 switch key { 11207 case "eq": 11208 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Eq, value); err != nil { 11209 return err 11210 } 11211 11212 case "eqExactMatch": 11213 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.EqExactMatch, value); err != nil { 11214 return err 11215 } 11216 11217 case "gt": 11218 if value != nil { 11219 jtv, ok := value.(json.Number) 11220 if !ok { 11221 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11222 } 11223 i64, err := jtv.Int64() 11224 if err != nil { 11225 return err 11226 } 11227 sv.Gt = i64 11228 } 11229 11230 case "gte": 11231 if value != nil { 11232 jtv, ok := value.(json.Number) 11233 if !ok { 11234 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11235 } 11236 i64, err := jtv.Int64() 11237 if err != nil { 11238 return err 11239 } 11240 sv.Gte = i64 11241 } 11242 11243 case "lt": 11244 if value != nil { 11245 jtv, ok := value.(json.Number) 11246 if !ok { 11247 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11248 } 11249 i64, err := jtv.Int64() 11250 if err != nil { 11251 return err 11252 } 11253 sv.Lt = i64 11254 } 11255 11256 case "lte": 11257 if value != nil { 11258 jtv, ok := value.(json.Number) 11259 if !ok { 11260 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11261 } 11262 i64, err := jtv.Int64() 11263 if err != nil { 11264 return err 11265 } 11266 sv.Lte = i64 11267 } 11268 11269 case "neq": 11270 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Neq, value); err != nil { 11271 return err 11272 } 11273 11274 default: 11275 _, _ = key, value 11276 11277 } 11278 } 11279 *v = sv 11280 return nil 11281} 11282 11283func awsRestjson1_deserializeDocumentCustomDataIdentifiers(v **types.CustomDataIdentifiers, value interface{}) error { 11284 if v == nil { 11285 return fmt.Errorf("unexpected nil of type %T", v) 11286 } 11287 if value == nil { 11288 return nil 11289 } 11290 11291 shape, ok := value.(map[string]interface{}) 11292 if !ok { 11293 return fmt.Errorf("unexpected JSON type %v", value) 11294 } 11295 11296 var sv *types.CustomDataIdentifiers 11297 if *v == nil { 11298 sv = &types.CustomDataIdentifiers{} 11299 } else { 11300 sv = *v 11301 } 11302 11303 for key, value := range shape { 11304 switch key { 11305 case "detections": 11306 if err := awsRestjson1_deserializeDocumentCustomDetections(&sv.Detections, value); err != nil { 11307 return err 11308 } 11309 11310 case "totalCount": 11311 if value != nil { 11312 jtv, ok := value.(json.Number) 11313 if !ok { 11314 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11315 } 11316 i64, err := jtv.Int64() 11317 if err != nil { 11318 return err 11319 } 11320 sv.TotalCount = i64 11321 } 11322 11323 default: 11324 _, _ = key, value 11325 11326 } 11327 } 11328 *v = sv 11329 return nil 11330} 11331 11332func awsRestjson1_deserializeDocumentCustomDataIdentifierSummary(v **types.CustomDataIdentifierSummary, value interface{}) error { 11333 if v == nil { 11334 return fmt.Errorf("unexpected nil of type %T", v) 11335 } 11336 if value == nil { 11337 return nil 11338 } 11339 11340 shape, ok := value.(map[string]interface{}) 11341 if !ok { 11342 return fmt.Errorf("unexpected JSON type %v", value) 11343 } 11344 11345 var sv *types.CustomDataIdentifierSummary 11346 if *v == nil { 11347 sv = &types.CustomDataIdentifierSummary{} 11348 } else { 11349 sv = *v 11350 } 11351 11352 for key, value := range shape { 11353 switch key { 11354 case "arn": 11355 if value != nil { 11356 jtv, ok := value.(string) 11357 if !ok { 11358 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11359 } 11360 sv.Arn = ptr.String(jtv) 11361 } 11362 11363 case "createdAt": 11364 if value != nil { 11365 jtv, ok := value.(string) 11366 if !ok { 11367 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 11368 } 11369 t, err := smithytime.ParseDateTime(jtv) 11370 if err != nil { 11371 return err 11372 } 11373 sv.CreatedAt = ptr.Time(t) 11374 } 11375 11376 case "description": 11377 if value != nil { 11378 jtv, ok := value.(string) 11379 if !ok { 11380 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11381 } 11382 sv.Description = ptr.String(jtv) 11383 } 11384 11385 case "id": 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.Id = ptr.String(jtv) 11392 } 11393 11394 case "name": 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.Name = ptr.String(jtv) 11401 } 11402 11403 default: 11404 _, _ = key, value 11405 11406 } 11407 } 11408 *v = sv 11409 return nil 11410} 11411 11412func awsRestjson1_deserializeDocumentCustomDetection(v **types.CustomDetection, value interface{}) error { 11413 if v == nil { 11414 return fmt.Errorf("unexpected nil of type %T", v) 11415 } 11416 if value == nil { 11417 return nil 11418 } 11419 11420 shape, ok := value.(map[string]interface{}) 11421 if !ok { 11422 return fmt.Errorf("unexpected JSON type %v", value) 11423 } 11424 11425 var sv *types.CustomDetection 11426 if *v == nil { 11427 sv = &types.CustomDetection{} 11428 } else { 11429 sv = *v 11430 } 11431 11432 for key, value := range shape { 11433 switch key { 11434 case "arn": 11435 if value != nil { 11436 jtv, ok := value.(string) 11437 if !ok { 11438 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11439 } 11440 sv.Arn = ptr.String(jtv) 11441 } 11442 11443 case "count": 11444 if value != nil { 11445 jtv, ok := value.(json.Number) 11446 if !ok { 11447 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11448 } 11449 i64, err := jtv.Int64() 11450 if err != nil { 11451 return err 11452 } 11453 sv.Count = i64 11454 } 11455 11456 case "name": 11457 if value != nil { 11458 jtv, ok := value.(string) 11459 if !ok { 11460 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11461 } 11462 sv.Name = ptr.String(jtv) 11463 } 11464 11465 case "occurrences": 11466 if err := awsRestjson1_deserializeDocumentOccurrences(&sv.Occurrences, value); err != nil { 11467 return err 11468 } 11469 11470 default: 11471 _, _ = key, value 11472 11473 } 11474 } 11475 *v = sv 11476 return nil 11477} 11478 11479func awsRestjson1_deserializeDocumentCustomDetections(v *[]types.CustomDetection, 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.([]interface{}) 11488 if !ok { 11489 return fmt.Errorf("unexpected JSON type %v", value) 11490 } 11491 11492 var cv []types.CustomDetection 11493 if *v == nil { 11494 cv = []types.CustomDetection{} 11495 } else { 11496 cv = *v 11497 } 11498 11499 for _, value := range shape { 11500 var col types.CustomDetection 11501 destAddr := &col 11502 if err := awsRestjson1_deserializeDocumentCustomDetection(&destAddr, value); err != nil { 11503 return err 11504 } 11505 col = *destAddr 11506 cv = append(cv, col) 11507 11508 } 11509 *v = cv 11510 return nil 11511} 11512 11513func awsRestjson1_deserializeDocumentDailySchedule(v **types.DailySchedule, value interface{}) error { 11514 if v == nil { 11515 return fmt.Errorf("unexpected nil of type %T", v) 11516 } 11517 if value == nil { 11518 return nil 11519 } 11520 11521 shape, ok := value.(map[string]interface{}) 11522 if !ok { 11523 return fmt.Errorf("unexpected JSON type %v", value) 11524 } 11525 11526 var sv *types.DailySchedule 11527 if *v == nil { 11528 sv = &types.DailySchedule{} 11529 } else { 11530 sv = *v 11531 } 11532 11533 for key, value := range shape { 11534 switch key { 11535 default: 11536 _, _ = key, value 11537 11538 } 11539 } 11540 *v = sv 11541 return nil 11542} 11543 11544func awsRestjson1_deserializeDocumentDefaultDetection(v **types.DefaultDetection, value interface{}) error { 11545 if v == nil { 11546 return fmt.Errorf("unexpected nil of type %T", v) 11547 } 11548 if value == nil { 11549 return nil 11550 } 11551 11552 shape, ok := value.(map[string]interface{}) 11553 if !ok { 11554 return fmt.Errorf("unexpected JSON type %v", value) 11555 } 11556 11557 var sv *types.DefaultDetection 11558 if *v == nil { 11559 sv = &types.DefaultDetection{} 11560 } else { 11561 sv = *v 11562 } 11563 11564 for key, value := range shape { 11565 switch key { 11566 case "count": 11567 if value != nil { 11568 jtv, ok := value.(json.Number) 11569 if !ok { 11570 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11571 } 11572 i64, err := jtv.Int64() 11573 if err != nil { 11574 return err 11575 } 11576 sv.Count = i64 11577 } 11578 11579 case "occurrences": 11580 if err := awsRestjson1_deserializeDocumentOccurrences(&sv.Occurrences, value); err != nil { 11581 return err 11582 } 11583 11584 case "type": 11585 if value != nil { 11586 jtv, ok := value.(string) 11587 if !ok { 11588 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11589 } 11590 sv.Type = ptr.String(jtv) 11591 } 11592 11593 default: 11594 _, _ = key, value 11595 11596 } 11597 } 11598 *v = sv 11599 return nil 11600} 11601 11602func awsRestjson1_deserializeDocumentDefaultDetections(v *[]types.DefaultDetection, value interface{}) error { 11603 if v == nil { 11604 return fmt.Errorf("unexpected nil of type %T", v) 11605 } 11606 if value == nil { 11607 return nil 11608 } 11609 11610 shape, ok := value.([]interface{}) 11611 if !ok { 11612 return fmt.Errorf("unexpected JSON type %v", value) 11613 } 11614 11615 var cv []types.DefaultDetection 11616 if *v == nil { 11617 cv = []types.DefaultDetection{} 11618 } else { 11619 cv = *v 11620 } 11621 11622 for _, value := range shape { 11623 var col types.DefaultDetection 11624 destAddr := &col 11625 if err := awsRestjson1_deserializeDocumentDefaultDetection(&destAddr, value); err != nil { 11626 return err 11627 } 11628 col = *destAddr 11629 cv = append(cv, col) 11630 11631 } 11632 *v = cv 11633 return nil 11634} 11635 11636func awsRestjson1_deserializeDocumentDomainDetails(v **types.DomainDetails, value interface{}) error { 11637 if v == nil { 11638 return fmt.Errorf("unexpected nil of type %T", v) 11639 } 11640 if value == nil { 11641 return nil 11642 } 11643 11644 shape, ok := value.(map[string]interface{}) 11645 if !ok { 11646 return fmt.Errorf("unexpected JSON type %v", value) 11647 } 11648 11649 var sv *types.DomainDetails 11650 if *v == nil { 11651 sv = &types.DomainDetails{} 11652 } else { 11653 sv = *v 11654 } 11655 11656 for key, value := range shape { 11657 switch key { 11658 case "domainName": 11659 if value != nil { 11660 jtv, ok := value.(string) 11661 if !ok { 11662 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11663 } 11664 sv.DomainName = ptr.String(jtv) 11665 } 11666 11667 default: 11668 _, _ = key, value 11669 11670 } 11671 } 11672 *v = sv 11673 return nil 11674} 11675 11676func awsRestjson1_deserializeDocumentFederatedUser(v **types.FederatedUser, value interface{}) error { 11677 if v == nil { 11678 return fmt.Errorf("unexpected nil of type %T", v) 11679 } 11680 if value == nil { 11681 return nil 11682 } 11683 11684 shape, ok := value.(map[string]interface{}) 11685 if !ok { 11686 return fmt.Errorf("unexpected JSON type %v", value) 11687 } 11688 11689 var sv *types.FederatedUser 11690 if *v == nil { 11691 sv = &types.FederatedUser{} 11692 } else { 11693 sv = *v 11694 } 11695 11696 for key, value := range shape { 11697 switch key { 11698 case "accessKeyId": 11699 if value != nil { 11700 jtv, ok := value.(string) 11701 if !ok { 11702 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11703 } 11704 sv.AccessKeyId = ptr.String(jtv) 11705 } 11706 11707 case "accountId": 11708 if value != nil { 11709 jtv, ok := value.(string) 11710 if !ok { 11711 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11712 } 11713 sv.AccountId = ptr.String(jtv) 11714 } 11715 11716 case "arn": 11717 if value != nil { 11718 jtv, ok := value.(string) 11719 if !ok { 11720 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11721 } 11722 sv.Arn = ptr.String(jtv) 11723 } 11724 11725 case "principalId": 11726 if value != nil { 11727 jtv, ok := value.(string) 11728 if !ok { 11729 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11730 } 11731 sv.PrincipalId = ptr.String(jtv) 11732 } 11733 11734 case "sessionContext": 11735 if err := awsRestjson1_deserializeDocumentSessionContext(&sv.SessionContext, value); err != nil { 11736 return err 11737 } 11738 11739 default: 11740 _, _ = key, value 11741 11742 } 11743 } 11744 *v = sv 11745 return nil 11746} 11747 11748func awsRestjson1_deserializeDocumentFinding(v **types.Finding, value interface{}) error { 11749 if v == nil { 11750 return fmt.Errorf("unexpected nil of type %T", v) 11751 } 11752 if value == nil { 11753 return nil 11754 } 11755 11756 shape, ok := value.(map[string]interface{}) 11757 if !ok { 11758 return fmt.Errorf("unexpected JSON type %v", value) 11759 } 11760 11761 var sv *types.Finding 11762 if *v == nil { 11763 sv = &types.Finding{} 11764 } else { 11765 sv = *v 11766 } 11767 11768 for key, value := range shape { 11769 switch key { 11770 case "accountId": 11771 if value != nil { 11772 jtv, ok := value.(string) 11773 if !ok { 11774 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11775 } 11776 sv.AccountId = ptr.String(jtv) 11777 } 11778 11779 case "archived": 11780 if value != nil { 11781 jtv, ok := value.(bool) 11782 if !ok { 11783 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 11784 } 11785 sv.Archived = jtv 11786 } 11787 11788 case "category": 11789 if value != nil { 11790 jtv, ok := value.(string) 11791 if !ok { 11792 return fmt.Errorf("expected FindingCategory to be of type string, got %T instead", value) 11793 } 11794 sv.Category = types.FindingCategory(jtv) 11795 } 11796 11797 case "classificationDetails": 11798 if err := awsRestjson1_deserializeDocumentClassificationDetails(&sv.ClassificationDetails, value); err != nil { 11799 return err 11800 } 11801 11802 case "count": 11803 if value != nil { 11804 jtv, ok := value.(json.Number) 11805 if !ok { 11806 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 11807 } 11808 i64, err := jtv.Int64() 11809 if err != nil { 11810 return err 11811 } 11812 sv.Count = i64 11813 } 11814 11815 case "createdAt": 11816 if value != nil { 11817 jtv, ok := value.(string) 11818 if !ok { 11819 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 11820 } 11821 t, err := smithytime.ParseDateTime(jtv) 11822 if err != nil { 11823 return err 11824 } 11825 sv.CreatedAt = ptr.Time(t) 11826 } 11827 11828 case "description": 11829 if value != nil { 11830 jtv, ok := value.(string) 11831 if !ok { 11832 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11833 } 11834 sv.Description = ptr.String(jtv) 11835 } 11836 11837 case "id": 11838 if value != nil { 11839 jtv, ok := value.(string) 11840 if !ok { 11841 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11842 } 11843 sv.Id = ptr.String(jtv) 11844 } 11845 11846 case "partition": 11847 if value != nil { 11848 jtv, ok := value.(string) 11849 if !ok { 11850 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11851 } 11852 sv.Partition = ptr.String(jtv) 11853 } 11854 11855 case "policyDetails": 11856 if err := awsRestjson1_deserializeDocumentPolicyDetails(&sv.PolicyDetails, value); err != nil { 11857 return err 11858 } 11859 11860 case "region": 11861 if value != nil { 11862 jtv, ok := value.(string) 11863 if !ok { 11864 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11865 } 11866 sv.Region = ptr.String(jtv) 11867 } 11868 11869 case "resourcesAffected": 11870 if err := awsRestjson1_deserializeDocumentResourcesAffected(&sv.ResourcesAffected, value); err != nil { 11871 return err 11872 } 11873 11874 case "sample": 11875 if value != nil { 11876 jtv, ok := value.(bool) 11877 if !ok { 11878 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 11879 } 11880 sv.Sample = jtv 11881 } 11882 11883 case "schemaVersion": 11884 if value != nil { 11885 jtv, ok := value.(string) 11886 if !ok { 11887 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11888 } 11889 sv.SchemaVersion = ptr.String(jtv) 11890 } 11891 11892 case "severity": 11893 if err := awsRestjson1_deserializeDocumentSeverity(&sv.Severity, value); err != nil { 11894 return err 11895 } 11896 11897 case "title": 11898 if value != nil { 11899 jtv, ok := value.(string) 11900 if !ok { 11901 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11902 } 11903 sv.Title = ptr.String(jtv) 11904 } 11905 11906 case "type": 11907 if value != nil { 11908 jtv, ok := value.(string) 11909 if !ok { 11910 return fmt.Errorf("expected FindingType to be of type string, got %T instead", value) 11911 } 11912 sv.Type = types.FindingType(jtv) 11913 } 11914 11915 case "updatedAt": 11916 if value != nil { 11917 jtv, ok := value.(string) 11918 if !ok { 11919 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 11920 } 11921 t, err := smithytime.ParseDateTime(jtv) 11922 if err != nil { 11923 return err 11924 } 11925 sv.UpdatedAt = ptr.Time(t) 11926 } 11927 11928 default: 11929 _, _ = key, value 11930 11931 } 11932 } 11933 *v = sv 11934 return nil 11935} 11936 11937func awsRestjson1_deserializeDocumentFindingAction(v **types.FindingAction, value interface{}) error { 11938 if v == nil { 11939 return fmt.Errorf("unexpected nil of type %T", v) 11940 } 11941 if value == nil { 11942 return nil 11943 } 11944 11945 shape, ok := value.(map[string]interface{}) 11946 if !ok { 11947 return fmt.Errorf("unexpected JSON type %v", value) 11948 } 11949 11950 var sv *types.FindingAction 11951 if *v == nil { 11952 sv = &types.FindingAction{} 11953 } else { 11954 sv = *v 11955 } 11956 11957 for key, value := range shape { 11958 switch key { 11959 case "actionType": 11960 if value != nil { 11961 jtv, ok := value.(string) 11962 if !ok { 11963 return fmt.Errorf("expected FindingActionType to be of type string, got %T instead", value) 11964 } 11965 sv.ActionType = types.FindingActionType(jtv) 11966 } 11967 11968 case "apiCallDetails": 11969 if err := awsRestjson1_deserializeDocumentApiCallDetails(&sv.ApiCallDetails, value); err != nil { 11970 return err 11971 } 11972 11973 default: 11974 _, _ = key, value 11975 11976 } 11977 } 11978 *v = sv 11979 return nil 11980} 11981 11982func awsRestjson1_deserializeDocumentFindingActor(v **types.FindingActor, value interface{}) error { 11983 if v == nil { 11984 return fmt.Errorf("unexpected nil of type %T", v) 11985 } 11986 if value == nil { 11987 return nil 11988 } 11989 11990 shape, ok := value.(map[string]interface{}) 11991 if !ok { 11992 return fmt.Errorf("unexpected JSON type %v", value) 11993 } 11994 11995 var sv *types.FindingActor 11996 if *v == nil { 11997 sv = &types.FindingActor{} 11998 } else { 11999 sv = *v 12000 } 12001 12002 for key, value := range shape { 12003 switch key { 12004 case "domainDetails": 12005 if err := awsRestjson1_deserializeDocumentDomainDetails(&sv.DomainDetails, value); err != nil { 12006 return err 12007 } 12008 12009 case "ipAddressDetails": 12010 if err := awsRestjson1_deserializeDocumentIpAddressDetails(&sv.IpAddressDetails, value); err != nil { 12011 return err 12012 } 12013 12014 case "userIdentity": 12015 if err := awsRestjson1_deserializeDocumentUserIdentity(&sv.UserIdentity, value); err != nil { 12016 return err 12017 } 12018 12019 default: 12020 _, _ = key, value 12021 12022 } 12023 } 12024 *v = sv 12025 return nil 12026} 12027 12028func awsRestjson1_deserializeDocumentFindingCriteria(v **types.FindingCriteria, value interface{}) error { 12029 if v == nil { 12030 return fmt.Errorf("unexpected nil of type %T", v) 12031 } 12032 if value == nil { 12033 return nil 12034 } 12035 12036 shape, ok := value.(map[string]interface{}) 12037 if !ok { 12038 return fmt.Errorf("unexpected JSON type %v", value) 12039 } 12040 12041 var sv *types.FindingCriteria 12042 if *v == nil { 12043 sv = &types.FindingCriteria{} 12044 } else { 12045 sv = *v 12046 } 12047 12048 for key, value := range shape { 12049 switch key { 12050 case "criterion": 12051 if err := awsRestjson1_deserializeDocumentCriterion(&sv.Criterion, value); err != nil { 12052 return err 12053 } 12054 12055 default: 12056 _, _ = key, value 12057 12058 } 12059 } 12060 *v = sv 12061 return nil 12062} 12063 12064func awsRestjson1_deserializeDocumentFindingsFilterListItem(v **types.FindingsFilterListItem, value interface{}) error { 12065 if v == nil { 12066 return fmt.Errorf("unexpected nil of type %T", v) 12067 } 12068 if value == nil { 12069 return nil 12070 } 12071 12072 shape, ok := value.(map[string]interface{}) 12073 if !ok { 12074 return fmt.Errorf("unexpected JSON type %v", value) 12075 } 12076 12077 var sv *types.FindingsFilterListItem 12078 if *v == nil { 12079 sv = &types.FindingsFilterListItem{} 12080 } else { 12081 sv = *v 12082 } 12083 12084 for key, value := range shape { 12085 switch key { 12086 case "action": 12087 if value != nil { 12088 jtv, ok := value.(string) 12089 if !ok { 12090 return fmt.Errorf("expected FindingsFilterAction to be of type string, got %T instead", value) 12091 } 12092 sv.Action = types.FindingsFilterAction(jtv) 12093 } 12094 12095 case "arn": 12096 if value != nil { 12097 jtv, ok := value.(string) 12098 if !ok { 12099 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12100 } 12101 sv.Arn = ptr.String(jtv) 12102 } 12103 12104 case "id": 12105 if value != nil { 12106 jtv, ok := value.(string) 12107 if !ok { 12108 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12109 } 12110 sv.Id = ptr.String(jtv) 12111 } 12112 12113 case "name": 12114 if value != nil { 12115 jtv, ok := value.(string) 12116 if !ok { 12117 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12118 } 12119 sv.Name = ptr.String(jtv) 12120 } 12121 12122 case "tags": 12123 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 12124 return err 12125 } 12126 12127 default: 12128 _, _ = key, value 12129 12130 } 12131 } 12132 *v = sv 12133 return nil 12134} 12135 12136func awsRestjson1_deserializeDocumentGroupCount(v **types.GroupCount, value interface{}) error { 12137 if v == nil { 12138 return fmt.Errorf("unexpected nil of type %T", v) 12139 } 12140 if value == nil { 12141 return nil 12142 } 12143 12144 shape, ok := value.(map[string]interface{}) 12145 if !ok { 12146 return fmt.Errorf("unexpected JSON type %v", value) 12147 } 12148 12149 var sv *types.GroupCount 12150 if *v == nil { 12151 sv = &types.GroupCount{} 12152 } else { 12153 sv = *v 12154 } 12155 12156 for key, value := range shape { 12157 switch key { 12158 case "count": 12159 if value != nil { 12160 jtv, ok := value.(json.Number) 12161 if !ok { 12162 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 12163 } 12164 i64, err := jtv.Int64() 12165 if err != nil { 12166 return err 12167 } 12168 sv.Count = i64 12169 } 12170 12171 case "groupKey": 12172 if value != nil { 12173 jtv, ok := value.(string) 12174 if !ok { 12175 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12176 } 12177 sv.GroupKey = ptr.String(jtv) 12178 } 12179 12180 default: 12181 _, _ = key, value 12182 12183 } 12184 } 12185 *v = sv 12186 return nil 12187} 12188 12189func awsRestjson1_deserializeDocumentIamUser(v **types.IamUser, value interface{}) error { 12190 if v == nil { 12191 return fmt.Errorf("unexpected nil of type %T", v) 12192 } 12193 if value == nil { 12194 return nil 12195 } 12196 12197 shape, ok := value.(map[string]interface{}) 12198 if !ok { 12199 return fmt.Errorf("unexpected JSON type %v", value) 12200 } 12201 12202 var sv *types.IamUser 12203 if *v == nil { 12204 sv = &types.IamUser{} 12205 } else { 12206 sv = *v 12207 } 12208 12209 for key, value := range shape { 12210 switch key { 12211 case "accountId": 12212 if value != nil { 12213 jtv, ok := value.(string) 12214 if !ok { 12215 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12216 } 12217 sv.AccountId = ptr.String(jtv) 12218 } 12219 12220 case "arn": 12221 if value != nil { 12222 jtv, ok := value.(string) 12223 if !ok { 12224 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12225 } 12226 sv.Arn = ptr.String(jtv) 12227 } 12228 12229 case "principalId": 12230 if value != nil { 12231 jtv, ok := value.(string) 12232 if !ok { 12233 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12234 } 12235 sv.PrincipalId = ptr.String(jtv) 12236 } 12237 12238 case "userName": 12239 if value != nil { 12240 jtv, ok := value.(string) 12241 if !ok { 12242 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12243 } 12244 sv.UserName = ptr.String(jtv) 12245 } 12246 12247 default: 12248 _, _ = key, value 12249 12250 } 12251 } 12252 *v = sv 12253 return nil 12254} 12255 12256func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { 12257 if v == nil { 12258 return fmt.Errorf("unexpected nil of type %T", v) 12259 } 12260 if value == nil { 12261 return nil 12262 } 12263 12264 shape, ok := value.(map[string]interface{}) 12265 if !ok { 12266 return fmt.Errorf("unexpected JSON type %v", value) 12267 } 12268 12269 var sv *types.InternalServerException 12270 if *v == nil { 12271 sv = &types.InternalServerException{} 12272 } else { 12273 sv = *v 12274 } 12275 12276 for key, value := range shape { 12277 switch key { 12278 case "message": 12279 if value != nil { 12280 jtv, ok := value.(string) 12281 if !ok { 12282 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12283 } 12284 sv.Message = ptr.String(jtv) 12285 } 12286 12287 default: 12288 _, _ = key, value 12289 12290 } 12291 } 12292 *v = sv 12293 return nil 12294} 12295 12296func awsRestjson1_deserializeDocumentInvitation(v **types.Invitation, value interface{}) error { 12297 if v == nil { 12298 return fmt.Errorf("unexpected nil of type %T", v) 12299 } 12300 if value == nil { 12301 return nil 12302 } 12303 12304 shape, ok := value.(map[string]interface{}) 12305 if !ok { 12306 return fmt.Errorf("unexpected JSON type %v", value) 12307 } 12308 12309 var sv *types.Invitation 12310 if *v == nil { 12311 sv = &types.Invitation{} 12312 } else { 12313 sv = *v 12314 } 12315 12316 for key, value := range shape { 12317 switch key { 12318 case "accountId": 12319 if value != nil { 12320 jtv, ok := value.(string) 12321 if !ok { 12322 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12323 } 12324 sv.AccountId = ptr.String(jtv) 12325 } 12326 12327 case "invitationId": 12328 if value != nil { 12329 jtv, ok := value.(string) 12330 if !ok { 12331 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12332 } 12333 sv.InvitationId = ptr.String(jtv) 12334 } 12335 12336 case "invitedAt": 12337 if value != nil { 12338 jtv, ok := value.(string) 12339 if !ok { 12340 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 12341 } 12342 t, err := smithytime.ParseDateTime(jtv) 12343 if err != nil { 12344 return err 12345 } 12346 sv.InvitedAt = ptr.Time(t) 12347 } 12348 12349 case "relationshipStatus": 12350 if value != nil { 12351 jtv, ok := value.(string) 12352 if !ok { 12353 return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value) 12354 } 12355 sv.RelationshipStatus = types.RelationshipStatus(jtv) 12356 } 12357 12358 default: 12359 _, _ = key, value 12360 12361 } 12362 } 12363 *v = sv 12364 return nil 12365} 12366 12367func awsRestjson1_deserializeDocumentIpAddressDetails(v **types.IpAddressDetails, value interface{}) error { 12368 if v == nil { 12369 return fmt.Errorf("unexpected nil of type %T", v) 12370 } 12371 if value == nil { 12372 return nil 12373 } 12374 12375 shape, ok := value.(map[string]interface{}) 12376 if !ok { 12377 return fmt.Errorf("unexpected JSON type %v", value) 12378 } 12379 12380 var sv *types.IpAddressDetails 12381 if *v == nil { 12382 sv = &types.IpAddressDetails{} 12383 } else { 12384 sv = *v 12385 } 12386 12387 for key, value := range shape { 12388 switch key { 12389 case "ipAddressV4": 12390 if value != nil { 12391 jtv, ok := value.(string) 12392 if !ok { 12393 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12394 } 12395 sv.IpAddressV4 = ptr.String(jtv) 12396 } 12397 12398 case "ipCity": 12399 if err := awsRestjson1_deserializeDocumentIpCity(&sv.IpCity, value); err != nil { 12400 return err 12401 } 12402 12403 case "ipCountry": 12404 if err := awsRestjson1_deserializeDocumentIpCountry(&sv.IpCountry, value); err != nil { 12405 return err 12406 } 12407 12408 case "ipGeoLocation": 12409 if err := awsRestjson1_deserializeDocumentIpGeoLocation(&sv.IpGeoLocation, value); err != nil { 12410 return err 12411 } 12412 12413 case "ipOwner": 12414 if err := awsRestjson1_deserializeDocumentIpOwner(&sv.IpOwner, value); err != nil { 12415 return err 12416 } 12417 12418 default: 12419 _, _ = key, value 12420 12421 } 12422 } 12423 *v = sv 12424 return nil 12425} 12426 12427func awsRestjson1_deserializeDocumentIpCity(v **types.IpCity, value interface{}) error { 12428 if v == nil { 12429 return fmt.Errorf("unexpected nil of type %T", v) 12430 } 12431 if value == nil { 12432 return nil 12433 } 12434 12435 shape, ok := value.(map[string]interface{}) 12436 if !ok { 12437 return fmt.Errorf("unexpected JSON type %v", value) 12438 } 12439 12440 var sv *types.IpCity 12441 if *v == nil { 12442 sv = &types.IpCity{} 12443 } else { 12444 sv = *v 12445 } 12446 12447 for key, value := range shape { 12448 switch key { 12449 case "name": 12450 if value != nil { 12451 jtv, ok := value.(string) 12452 if !ok { 12453 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12454 } 12455 sv.Name = ptr.String(jtv) 12456 } 12457 12458 default: 12459 _, _ = key, value 12460 12461 } 12462 } 12463 *v = sv 12464 return nil 12465} 12466 12467func awsRestjson1_deserializeDocumentIpCountry(v **types.IpCountry, value interface{}) error { 12468 if v == nil { 12469 return fmt.Errorf("unexpected nil of type %T", v) 12470 } 12471 if value == nil { 12472 return nil 12473 } 12474 12475 shape, ok := value.(map[string]interface{}) 12476 if !ok { 12477 return fmt.Errorf("unexpected JSON type %v", value) 12478 } 12479 12480 var sv *types.IpCountry 12481 if *v == nil { 12482 sv = &types.IpCountry{} 12483 } else { 12484 sv = *v 12485 } 12486 12487 for key, value := range shape { 12488 switch key { 12489 case "code": 12490 if value != nil { 12491 jtv, ok := value.(string) 12492 if !ok { 12493 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12494 } 12495 sv.Code = ptr.String(jtv) 12496 } 12497 12498 case "name": 12499 if value != nil { 12500 jtv, ok := value.(string) 12501 if !ok { 12502 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12503 } 12504 sv.Name = ptr.String(jtv) 12505 } 12506 12507 default: 12508 _, _ = key, value 12509 12510 } 12511 } 12512 *v = sv 12513 return nil 12514} 12515 12516func awsRestjson1_deserializeDocumentIpGeoLocation(v **types.IpGeoLocation, value interface{}) error { 12517 if v == nil { 12518 return fmt.Errorf("unexpected nil of type %T", v) 12519 } 12520 if value == nil { 12521 return nil 12522 } 12523 12524 shape, ok := value.(map[string]interface{}) 12525 if !ok { 12526 return fmt.Errorf("unexpected JSON type %v", value) 12527 } 12528 12529 var sv *types.IpGeoLocation 12530 if *v == nil { 12531 sv = &types.IpGeoLocation{} 12532 } else { 12533 sv = *v 12534 } 12535 12536 for key, value := range shape { 12537 switch key { 12538 case "lat": 12539 if value != nil { 12540 jtv, ok := value.(json.Number) 12541 if !ok { 12542 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 12543 } 12544 f64, err := jtv.Float64() 12545 if err != nil { 12546 return err 12547 } 12548 sv.Lat = f64 12549 } 12550 12551 case "lon": 12552 if value != nil { 12553 jtv, ok := value.(json.Number) 12554 if !ok { 12555 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 12556 } 12557 f64, err := jtv.Float64() 12558 if err != nil { 12559 return err 12560 } 12561 sv.Lon = f64 12562 } 12563 12564 default: 12565 _, _ = key, value 12566 12567 } 12568 } 12569 *v = sv 12570 return nil 12571} 12572 12573func awsRestjson1_deserializeDocumentIpOwner(v **types.IpOwner, value interface{}) error { 12574 if v == nil { 12575 return fmt.Errorf("unexpected nil of type %T", v) 12576 } 12577 if value == nil { 12578 return nil 12579 } 12580 12581 shape, ok := value.(map[string]interface{}) 12582 if !ok { 12583 return fmt.Errorf("unexpected JSON type %v", value) 12584 } 12585 12586 var sv *types.IpOwner 12587 if *v == nil { 12588 sv = &types.IpOwner{} 12589 } else { 12590 sv = *v 12591 } 12592 12593 for key, value := range shape { 12594 switch key { 12595 case "asn": 12596 if value != nil { 12597 jtv, ok := value.(string) 12598 if !ok { 12599 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12600 } 12601 sv.Asn = ptr.String(jtv) 12602 } 12603 12604 case "asnOrg": 12605 if value != nil { 12606 jtv, ok := value.(string) 12607 if !ok { 12608 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12609 } 12610 sv.AsnOrg = ptr.String(jtv) 12611 } 12612 12613 case "isp": 12614 if value != nil { 12615 jtv, ok := value.(string) 12616 if !ok { 12617 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12618 } 12619 sv.Isp = ptr.String(jtv) 12620 } 12621 12622 case "org": 12623 if value != nil { 12624 jtv, ok := value.(string) 12625 if !ok { 12626 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12627 } 12628 sv.Org = ptr.String(jtv) 12629 } 12630 12631 default: 12632 _, _ = key, value 12633 12634 } 12635 } 12636 *v = sv 12637 return nil 12638} 12639 12640func awsRestjson1_deserializeDocumentJobDetails(v **types.JobDetails, value interface{}) error { 12641 if v == nil { 12642 return fmt.Errorf("unexpected nil of type %T", v) 12643 } 12644 if value == nil { 12645 return nil 12646 } 12647 12648 shape, ok := value.(map[string]interface{}) 12649 if !ok { 12650 return fmt.Errorf("unexpected JSON type %v", value) 12651 } 12652 12653 var sv *types.JobDetails 12654 if *v == nil { 12655 sv = &types.JobDetails{} 12656 } else { 12657 sv = *v 12658 } 12659 12660 for key, value := range shape { 12661 switch key { 12662 case "isDefinedInJob": 12663 if value != nil { 12664 jtv, ok := value.(string) 12665 if !ok { 12666 return fmt.Errorf("expected IsDefinedInJob to be of type string, got %T instead", value) 12667 } 12668 sv.IsDefinedInJob = types.IsDefinedInJob(jtv) 12669 } 12670 12671 case "isMonitoredByJob": 12672 if value != nil { 12673 jtv, ok := value.(string) 12674 if !ok { 12675 return fmt.Errorf("expected IsMonitoredByJob to be of type string, got %T instead", value) 12676 } 12677 sv.IsMonitoredByJob = types.IsMonitoredByJob(jtv) 12678 } 12679 12680 case "lastJobId": 12681 if value != nil { 12682 jtv, ok := value.(string) 12683 if !ok { 12684 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12685 } 12686 sv.LastJobId = ptr.String(jtv) 12687 } 12688 12689 case "lastJobRunTime": 12690 if value != nil { 12691 jtv, ok := value.(string) 12692 if !ok { 12693 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 12694 } 12695 t, err := smithytime.ParseDateTime(jtv) 12696 if err != nil { 12697 return err 12698 } 12699 sv.LastJobRunTime = ptr.Time(t) 12700 } 12701 12702 default: 12703 _, _ = key, value 12704 12705 } 12706 } 12707 *v = sv 12708 return nil 12709} 12710 12711func awsRestjson1_deserializeDocumentJobScheduleFrequency(v **types.JobScheduleFrequency, value interface{}) error { 12712 if v == nil { 12713 return fmt.Errorf("unexpected nil of type %T", v) 12714 } 12715 if value == nil { 12716 return nil 12717 } 12718 12719 shape, ok := value.(map[string]interface{}) 12720 if !ok { 12721 return fmt.Errorf("unexpected JSON type %v", value) 12722 } 12723 12724 var sv *types.JobScheduleFrequency 12725 if *v == nil { 12726 sv = &types.JobScheduleFrequency{} 12727 } else { 12728 sv = *v 12729 } 12730 12731 for key, value := range shape { 12732 switch key { 12733 case "dailySchedule": 12734 if err := awsRestjson1_deserializeDocumentDailySchedule(&sv.DailySchedule, value); err != nil { 12735 return err 12736 } 12737 12738 case "monthlySchedule": 12739 if err := awsRestjson1_deserializeDocumentMonthlySchedule(&sv.MonthlySchedule, value); err != nil { 12740 return err 12741 } 12742 12743 case "weeklySchedule": 12744 if err := awsRestjson1_deserializeDocumentWeeklySchedule(&sv.WeeklySchedule, value); err != nil { 12745 return err 12746 } 12747 12748 default: 12749 _, _ = key, value 12750 12751 } 12752 } 12753 *v = sv 12754 return nil 12755} 12756 12757func awsRestjson1_deserializeDocumentJobScopeTerm(v **types.JobScopeTerm, value interface{}) error { 12758 if v == nil { 12759 return fmt.Errorf("unexpected nil of type %T", v) 12760 } 12761 if value == nil { 12762 return nil 12763 } 12764 12765 shape, ok := value.(map[string]interface{}) 12766 if !ok { 12767 return fmt.Errorf("unexpected JSON type %v", value) 12768 } 12769 12770 var sv *types.JobScopeTerm 12771 if *v == nil { 12772 sv = &types.JobScopeTerm{} 12773 } else { 12774 sv = *v 12775 } 12776 12777 for key, value := range shape { 12778 switch key { 12779 case "simpleScopeTerm": 12780 if err := awsRestjson1_deserializeDocumentSimpleScopeTerm(&sv.SimpleScopeTerm, value); err != nil { 12781 return err 12782 } 12783 12784 case "tagScopeTerm": 12785 if err := awsRestjson1_deserializeDocumentTagScopeTerm(&sv.TagScopeTerm, value); err != nil { 12786 return err 12787 } 12788 12789 default: 12790 _, _ = key, value 12791 12792 } 12793 } 12794 *v = sv 12795 return nil 12796} 12797 12798func awsRestjson1_deserializeDocumentJobScopingBlock(v **types.JobScopingBlock, value interface{}) error { 12799 if v == nil { 12800 return fmt.Errorf("unexpected nil of type %T", v) 12801 } 12802 if value == nil { 12803 return nil 12804 } 12805 12806 shape, ok := value.(map[string]interface{}) 12807 if !ok { 12808 return fmt.Errorf("unexpected JSON type %v", value) 12809 } 12810 12811 var sv *types.JobScopingBlock 12812 if *v == nil { 12813 sv = &types.JobScopingBlock{} 12814 } else { 12815 sv = *v 12816 } 12817 12818 for key, value := range shape { 12819 switch key { 12820 case "and": 12821 if err := awsRestjson1_deserializeDocument__listOfJobScopeTerm(&sv.And, value); err != nil { 12822 return err 12823 } 12824 12825 default: 12826 _, _ = key, value 12827 12828 } 12829 } 12830 *v = sv 12831 return nil 12832} 12833 12834func awsRestjson1_deserializeDocumentJobSummary(v **types.JobSummary, value interface{}) error { 12835 if v == nil { 12836 return fmt.Errorf("unexpected nil of type %T", v) 12837 } 12838 if value == nil { 12839 return nil 12840 } 12841 12842 shape, ok := value.(map[string]interface{}) 12843 if !ok { 12844 return fmt.Errorf("unexpected JSON type %v", value) 12845 } 12846 12847 var sv *types.JobSummary 12848 if *v == nil { 12849 sv = &types.JobSummary{} 12850 } else { 12851 sv = *v 12852 } 12853 12854 for key, value := range shape { 12855 switch key { 12856 case "bucketDefinitions": 12857 if err := awsRestjson1_deserializeDocument__listOfS3BucketDefinitionForJob(&sv.BucketDefinitions, value); err != nil { 12858 return err 12859 } 12860 12861 case "createdAt": 12862 if value != nil { 12863 jtv, ok := value.(string) 12864 if !ok { 12865 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 12866 } 12867 t, err := smithytime.ParseDateTime(jtv) 12868 if err != nil { 12869 return err 12870 } 12871 sv.CreatedAt = ptr.Time(t) 12872 } 12873 12874 case "jobId": 12875 if value != nil { 12876 jtv, ok := value.(string) 12877 if !ok { 12878 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12879 } 12880 sv.JobId = ptr.String(jtv) 12881 } 12882 12883 case "jobStatus": 12884 if value != nil { 12885 jtv, ok := value.(string) 12886 if !ok { 12887 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 12888 } 12889 sv.JobStatus = types.JobStatus(jtv) 12890 } 12891 12892 case "jobType": 12893 if value != nil { 12894 jtv, ok := value.(string) 12895 if !ok { 12896 return fmt.Errorf("expected JobType to be of type string, got %T instead", value) 12897 } 12898 sv.JobType = types.JobType(jtv) 12899 } 12900 12901 case "lastRunErrorStatus": 12902 if err := awsRestjson1_deserializeDocumentLastRunErrorStatus(&sv.LastRunErrorStatus, value); err != nil { 12903 return err 12904 } 12905 12906 case "name": 12907 if value != nil { 12908 jtv, ok := value.(string) 12909 if !ok { 12910 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12911 } 12912 sv.Name = ptr.String(jtv) 12913 } 12914 12915 case "userPausedDetails": 12916 if err := awsRestjson1_deserializeDocumentUserPausedDetails(&sv.UserPausedDetails, value); err != nil { 12917 return err 12918 } 12919 12920 default: 12921 _, _ = key, value 12922 12923 } 12924 } 12925 *v = sv 12926 return nil 12927} 12928 12929func awsRestjson1_deserializeDocumentKeyValuePair(v **types.KeyValuePair, value interface{}) error { 12930 if v == nil { 12931 return fmt.Errorf("unexpected nil of type %T", v) 12932 } 12933 if value == nil { 12934 return nil 12935 } 12936 12937 shape, ok := value.(map[string]interface{}) 12938 if !ok { 12939 return fmt.Errorf("unexpected JSON type %v", value) 12940 } 12941 12942 var sv *types.KeyValuePair 12943 if *v == nil { 12944 sv = &types.KeyValuePair{} 12945 } else { 12946 sv = *v 12947 } 12948 12949 for key, value := range shape { 12950 switch key { 12951 case "key": 12952 if value != nil { 12953 jtv, ok := value.(string) 12954 if !ok { 12955 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12956 } 12957 sv.Key = ptr.String(jtv) 12958 } 12959 12960 case "value": 12961 if value != nil { 12962 jtv, ok := value.(string) 12963 if !ok { 12964 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12965 } 12966 sv.Value = ptr.String(jtv) 12967 } 12968 12969 default: 12970 _, _ = key, value 12971 12972 } 12973 } 12974 *v = sv 12975 return nil 12976} 12977 12978func awsRestjson1_deserializeDocumentKeyValuePairList(v *[]types.KeyValuePair, value interface{}) error { 12979 if v == nil { 12980 return fmt.Errorf("unexpected nil of type %T", v) 12981 } 12982 if value == nil { 12983 return nil 12984 } 12985 12986 shape, ok := value.([]interface{}) 12987 if !ok { 12988 return fmt.Errorf("unexpected JSON type %v", value) 12989 } 12990 12991 var cv []types.KeyValuePair 12992 if *v == nil { 12993 cv = []types.KeyValuePair{} 12994 } else { 12995 cv = *v 12996 } 12997 12998 for _, value := range shape { 12999 var col types.KeyValuePair 13000 destAddr := &col 13001 if err := awsRestjson1_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 13002 return err 13003 } 13004 col = *destAddr 13005 cv = append(cv, col) 13006 13007 } 13008 *v = cv 13009 return nil 13010} 13011 13012func awsRestjson1_deserializeDocumentLastRunErrorStatus(v **types.LastRunErrorStatus, value interface{}) error { 13013 if v == nil { 13014 return fmt.Errorf("unexpected nil of type %T", v) 13015 } 13016 if value == nil { 13017 return nil 13018 } 13019 13020 shape, ok := value.(map[string]interface{}) 13021 if !ok { 13022 return fmt.Errorf("unexpected JSON type %v", value) 13023 } 13024 13025 var sv *types.LastRunErrorStatus 13026 if *v == nil { 13027 sv = &types.LastRunErrorStatus{} 13028 } else { 13029 sv = *v 13030 } 13031 13032 for key, value := range shape { 13033 switch key { 13034 case "code": 13035 if value != nil { 13036 jtv, ok := value.(string) 13037 if !ok { 13038 return fmt.Errorf("expected LastRunErrorStatusCode to be of type string, got %T instead", value) 13039 } 13040 sv.Code = types.LastRunErrorStatusCode(jtv) 13041 } 13042 13043 default: 13044 _, _ = key, value 13045 13046 } 13047 } 13048 *v = sv 13049 return nil 13050} 13051 13052func awsRestjson1_deserializeDocumentMember(v **types.Member, value interface{}) error { 13053 if v == nil { 13054 return fmt.Errorf("unexpected nil of type %T", v) 13055 } 13056 if value == nil { 13057 return nil 13058 } 13059 13060 shape, ok := value.(map[string]interface{}) 13061 if !ok { 13062 return fmt.Errorf("unexpected JSON type %v", value) 13063 } 13064 13065 var sv *types.Member 13066 if *v == nil { 13067 sv = &types.Member{} 13068 } else { 13069 sv = *v 13070 } 13071 13072 for key, value := range shape { 13073 switch key { 13074 case "accountId": 13075 if value != nil { 13076 jtv, ok := value.(string) 13077 if !ok { 13078 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13079 } 13080 sv.AccountId = ptr.String(jtv) 13081 } 13082 13083 case "administratorAccountId": 13084 if value != nil { 13085 jtv, ok := value.(string) 13086 if !ok { 13087 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13088 } 13089 sv.AdministratorAccountId = ptr.String(jtv) 13090 } 13091 13092 case "arn": 13093 if value != nil { 13094 jtv, ok := value.(string) 13095 if !ok { 13096 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13097 } 13098 sv.Arn = ptr.String(jtv) 13099 } 13100 13101 case "email": 13102 if value != nil { 13103 jtv, ok := value.(string) 13104 if !ok { 13105 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13106 } 13107 sv.Email = ptr.String(jtv) 13108 } 13109 13110 case "invitedAt": 13111 if value != nil { 13112 jtv, ok := value.(string) 13113 if !ok { 13114 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 13115 } 13116 t, err := smithytime.ParseDateTime(jtv) 13117 if err != nil { 13118 return err 13119 } 13120 sv.InvitedAt = ptr.Time(t) 13121 } 13122 13123 case "masterAccountId": 13124 if value != nil { 13125 jtv, ok := value.(string) 13126 if !ok { 13127 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13128 } 13129 sv.MasterAccountId = ptr.String(jtv) 13130 } 13131 13132 case "relationshipStatus": 13133 if value != nil { 13134 jtv, ok := value.(string) 13135 if !ok { 13136 return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value) 13137 } 13138 sv.RelationshipStatus = types.RelationshipStatus(jtv) 13139 } 13140 13141 case "tags": 13142 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 13143 return err 13144 } 13145 13146 case "updatedAt": 13147 if value != nil { 13148 jtv, ok := value.(string) 13149 if !ok { 13150 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 13151 } 13152 t, err := smithytime.ParseDateTime(jtv) 13153 if err != nil { 13154 return err 13155 } 13156 sv.UpdatedAt = ptr.Time(t) 13157 } 13158 13159 default: 13160 _, _ = key, value 13161 13162 } 13163 } 13164 *v = sv 13165 return nil 13166} 13167 13168func awsRestjson1_deserializeDocumentMonthlySchedule(v **types.MonthlySchedule, value interface{}) error { 13169 if v == nil { 13170 return fmt.Errorf("unexpected nil of type %T", v) 13171 } 13172 if value == nil { 13173 return nil 13174 } 13175 13176 shape, ok := value.(map[string]interface{}) 13177 if !ok { 13178 return fmt.Errorf("unexpected JSON type %v", value) 13179 } 13180 13181 var sv *types.MonthlySchedule 13182 if *v == nil { 13183 sv = &types.MonthlySchedule{} 13184 } else { 13185 sv = *v 13186 } 13187 13188 for key, value := range shape { 13189 switch key { 13190 case "dayOfMonth": 13191 if value != nil { 13192 jtv, ok := value.(json.Number) 13193 if !ok { 13194 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 13195 } 13196 i64, err := jtv.Int64() 13197 if err != nil { 13198 return err 13199 } 13200 sv.DayOfMonth = int32(i64) 13201 } 13202 13203 default: 13204 _, _ = key, value 13205 13206 } 13207 } 13208 *v = sv 13209 return nil 13210} 13211 13212func awsRestjson1_deserializeDocumentObjectCountByEncryptionType(v **types.ObjectCountByEncryptionType, value interface{}) error { 13213 if v == nil { 13214 return fmt.Errorf("unexpected nil of type %T", v) 13215 } 13216 if value == nil { 13217 return nil 13218 } 13219 13220 shape, ok := value.(map[string]interface{}) 13221 if !ok { 13222 return fmt.Errorf("unexpected JSON type %v", value) 13223 } 13224 13225 var sv *types.ObjectCountByEncryptionType 13226 if *v == nil { 13227 sv = &types.ObjectCountByEncryptionType{} 13228 } else { 13229 sv = *v 13230 } 13231 13232 for key, value := range shape { 13233 switch key { 13234 case "customerManaged": 13235 if value != nil { 13236 jtv, ok := value.(json.Number) 13237 if !ok { 13238 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13239 } 13240 i64, err := jtv.Int64() 13241 if err != nil { 13242 return err 13243 } 13244 sv.CustomerManaged = i64 13245 } 13246 13247 case "kmsManaged": 13248 if value != nil { 13249 jtv, ok := value.(json.Number) 13250 if !ok { 13251 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13252 } 13253 i64, err := jtv.Int64() 13254 if err != nil { 13255 return err 13256 } 13257 sv.KmsManaged = i64 13258 } 13259 13260 case "s3Managed": 13261 if value != nil { 13262 jtv, ok := value.(json.Number) 13263 if !ok { 13264 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13265 } 13266 i64, err := jtv.Int64() 13267 if err != nil { 13268 return err 13269 } 13270 sv.S3Managed = i64 13271 } 13272 13273 case "unencrypted": 13274 if value != nil { 13275 jtv, ok := value.(json.Number) 13276 if !ok { 13277 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13278 } 13279 i64, err := jtv.Int64() 13280 if err != nil { 13281 return err 13282 } 13283 sv.Unencrypted = i64 13284 } 13285 13286 case "unknown": 13287 if value != nil { 13288 jtv, ok := value.(json.Number) 13289 if !ok { 13290 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13291 } 13292 i64, err := jtv.Int64() 13293 if err != nil { 13294 return err 13295 } 13296 sv.Unknown = i64 13297 } 13298 13299 default: 13300 _, _ = key, value 13301 13302 } 13303 } 13304 *v = sv 13305 return nil 13306} 13307 13308func awsRestjson1_deserializeDocumentObjectLevelStatistics(v **types.ObjectLevelStatistics, value interface{}) error { 13309 if v == nil { 13310 return fmt.Errorf("unexpected nil of type %T", v) 13311 } 13312 if value == nil { 13313 return nil 13314 } 13315 13316 shape, ok := value.(map[string]interface{}) 13317 if !ok { 13318 return fmt.Errorf("unexpected JSON type %v", value) 13319 } 13320 13321 var sv *types.ObjectLevelStatistics 13322 if *v == nil { 13323 sv = &types.ObjectLevelStatistics{} 13324 } else { 13325 sv = *v 13326 } 13327 13328 for key, value := range shape { 13329 switch key { 13330 case "fileType": 13331 if value != nil { 13332 jtv, ok := value.(json.Number) 13333 if !ok { 13334 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13335 } 13336 i64, err := jtv.Int64() 13337 if err != nil { 13338 return err 13339 } 13340 sv.FileType = i64 13341 } 13342 13343 case "storageClass": 13344 if value != nil { 13345 jtv, ok := value.(json.Number) 13346 if !ok { 13347 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13348 } 13349 i64, err := jtv.Int64() 13350 if err != nil { 13351 return err 13352 } 13353 sv.StorageClass = i64 13354 } 13355 13356 case "total": 13357 if value != nil { 13358 jtv, ok := value.(json.Number) 13359 if !ok { 13360 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13361 } 13362 i64, err := jtv.Int64() 13363 if err != nil { 13364 return err 13365 } 13366 sv.Total = i64 13367 } 13368 13369 default: 13370 _, _ = key, value 13371 13372 } 13373 } 13374 *v = sv 13375 return nil 13376} 13377 13378func awsRestjson1_deserializeDocumentOccurrences(v **types.Occurrences, value interface{}) error { 13379 if v == nil { 13380 return fmt.Errorf("unexpected nil of type %T", v) 13381 } 13382 if value == nil { 13383 return nil 13384 } 13385 13386 shape, ok := value.(map[string]interface{}) 13387 if !ok { 13388 return fmt.Errorf("unexpected JSON type %v", value) 13389 } 13390 13391 var sv *types.Occurrences 13392 if *v == nil { 13393 sv = &types.Occurrences{} 13394 } else { 13395 sv = *v 13396 } 13397 13398 for key, value := range shape { 13399 switch key { 13400 case "cells": 13401 if err := awsRestjson1_deserializeDocumentCells(&sv.Cells, value); err != nil { 13402 return err 13403 } 13404 13405 case "lineRanges": 13406 if err := awsRestjson1_deserializeDocumentRanges(&sv.LineRanges, value); err != nil { 13407 return err 13408 } 13409 13410 case "offsetRanges": 13411 if err := awsRestjson1_deserializeDocumentRanges(&sv.OffsetRanges, value); err != nil { 13412 return err 13413 } 13414 13415 case "pages": 13416 if err := awsRestjson1_deserializeDocumentPages(&sv.Pages, value); err != nil { 13417 return err 13418 } 13419 13420 case "records": 13421 if err := awsRestjson1_deserializeDocumentRecords(&sv.Records, value); err != nil { 13422 return err 13423 } 13424 13425 default: 13426 _, _ = key, value 13427 13428 } 13429 } 13430 *v = sv 13431 return nil 13432} 13433 13434func awsRestjson1_deserializeDocumentPage(v **types.Page, value interface{}) error { 13435 if v == nil { 13436 return fmt.Errorf("unexpected nil of type %T", v) 13437 } 13438 if value == nil { 13439 return nil 13440 } 13441 13442 shape, ok := value.(map[string]interface{}) 13443 if !ok { 13444 return fmt.Errorf("unexpected JSON type %v", value) 13445 } 13446 13447 var sv *types.Page 13448 if *v == nil { 13449 sv = &types.Page{} 13450 } else { 13451 sv = *v 13452 } 13453 13454 for key, value := range shape { 13455 switch key { 13456 case "lineRange": 13457 if err := awsRestjson1_deserializeDocumentRange(&sv.LineRange, value); err != nil { 13458 return err 13459 } 13460 13461 case "offsetRange": 13462 if err := awsRestjson1_deserializeDocumentRange(&sv.OffsetRange, value); err != nil { 13463 return err 13464 } 13465 13466 case "pageNumber": 13467 if value != nil { 13468 jtv, ok := value.(json.Number) 13469 if !ok { 13470 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13471 } 13472 i64, err := jtv.Int64() 13473 if err != nil { 13474 return err 13475 } 13476 sv.PageNumber = i64 13477 } 13478 13479 default: 13480 _, _ = key, value 13481 13482 } 13483 } 13484 *v = sv 13485 return nil 13486} 13487 13488func awsRestjson1_deserializeDocumentPages(v *[]types.Page, value interface{}) error { 13489 if v == nil { 13490 return fmt.Errorf("unexpected nil of type %T", v) 13491 } 13492 if value == nil { 13493 return nil 13494 } 13495 13496 shape, ok := value.([]interface{}) 13497 if !ok { 13498 return fmt.Errorf("unexpected JSON type %v", value) 13499 } 13500 13501 var cv []types.Page 13502 if *v == nil { 13503 cv = []types.Page{} 13504 } else { 13505 cv = *v 13506 } 13507 13508 for _, value := range shape { 13509 var col types.Page 13510 destAddr := &col 13511 if err := awsRestjson1_deserializeDocumentPage(&destAddr, value); err != nil { 13512 return err 13513 } 13514 col = *destAddr 13515 cv = append(cv, col) 13516 13517 } 13518 *v = cv 13519 return nil 13520} 13521 13522func awsRestjson1_deserializeDocumentPolicyDetails(v **types.PolicyDetails, value interface{}) error { 13523 if v == nil { 13524 return fmt.Errorf("unexpected nil of type %T", v) 13525 } 13526 if value == nil { 13527 return nil 13528 } 13529 13530 shape, ok := value.(map[string]interface{}) 13531 if !ok { 13532 return fmt.Errorf("unexpected JSON type %v", value) 13533 } 13534 13535 var sv *types.PolicyDetails 13536 if *v == nil { 13537 sv = &types.PolicyDetails{} 13538 } else { 13539 sv = *v 13540 } 13541 13542 for key, value := range shape { 13543 switch key { 13544 case "action": 13545 if err := awsRestjson1_deserializeDocumentFindingAction(&sv.Action, value); err != nil { 13546 return err 13547 } 13548 13549 case "actor": 13550 if err := awsRestjson1_deserializeDocumentFindingActor(&sv.Actor, value); err != nil { 13551 return err 13552 } 13553 13554 default: 13555 _, _ = key, value 13556 13557 } 13558 } 13559 *v = sv 13560 return nil 13561} 13562 13563func awsRestjson1_deserializeDocumentRange(v **types.Range, value interface{}) error { 13564 if v == nil { 13565 return fmt.Errorf("unexpected nil of type %T", v) 13566 } 13567 if value == nil { 13568 return nil 13569 } 13570 13571 shape, ok := value.(map[string]interface{}) 13572 if !ok { 13573 return fmt.Errorf("unexpected JSON type %v", value) 13574 } 13575 13576 var sv *types.Range 13577 if *v == nil { 13578 sv = &types.Range{} 13579 } else { 13580 sv = *v 13581 } 13582 13583 for key, value := range shape { 13584 switch key { 13585 case "end": 13586 if value != nil { 13587 jtv, ok := value.(json.Number) 13588 if !ok { 13589 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13590 } 13591 i64, err := jtv.Int64() 13592 if err != nil { 13593 return err 13594 } 13595 sv.End = i64 13596 } 13597 13598 case "start": 13599 if value != nil { 13600 jtv, ok := value.(json.Number) 13601 if !ok { 13602 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13603 } 13604 i64, err := jtv.Int64() 13605 if err != nil { 13606 return err 13607 } 13608 sv.Start = i64 13609 } 13610 13611 case "startColumn": 13612 if value != nil { 13613 jtv, ok := value.(json.Number) 13614 if !ok { 13615 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13616 } 13617 i64, err := jtv.Int64() 13618 if err != nil { 13619 return err 13620 } 13621 sv.StartColumn = i64 13622 } 13623 13624 default: 13625 _, _ = key, value 13626 13627 } 13628 } 13629 *v = sv 13630 return nil 13631} 13632 13633func awsRestjson1_deserializeDocumentRanges(v *[]types.Range, value interface{}) error { 13634 if v == nil { 13635 return fmt.Errorf("unexpected nil of type %T", v) 13636 } 13637 if value == nil { 13638 return nil 13639 } 13640 13641 shape, ok := value.([]interface{}) 13642 if !ok { 13643 return fmt.Errorf("unexpected JSON type %v", value) 13644 } 13645 13646 var cv []types.Range 13647 if *v == nil { 13648 cv = []types.Range{} 13649 } else { 13650 cv = *v 13651 } 13652 13653 for _, value := range shape { 13654 var col types.Range 13655 destAddr := &col 13656 if err := awsRestjson1_deserializeDocumentRange(&destAddr, value); err != nil { 13657 return err 13658 } 13659 col = *destAddr 13660 cv = append(cv, col) 13661 13662 } 13663 *v = cv 13664 return nil 13665} 13666 13667func awsRestjson1_deserializeDocumentRecord(v **types.Record, value interface{}) error { 13668 if v == nil { 13669 return fmt.Errorf("unexpected nil of type %T", v) 13670 } 13671 if value == nil { 13672 return nil 13673 } 13674 13675 shape, ok := value.(map[string]interface{}) 13676 if !ok { 13677 return fmt.Errorf("unexpected JSON type %v", value) 13678 } 13679 13680 var sv *types.Record 13681 if *v == nil { 13682 sv = &types.Record{} 13683 } else { 13684 sv = *v 13685 } 13686 13687 for key, value := range shape { 13688 switch key { 13689 case "jsonPath": 13690 if value != nil { 13691 jtv, ok := value.(string) 13692 if !ok { 13693 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13694 } 13695 sv.JsonPath = ptr.String(jtv) 13696 } 13697 13698 case "recordIndex": 13699 if value != nil { 13700 jtv, ok := value.(json.Number) 13701 if !ok { 13702 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 13703 } 13704 i64, err := jtv.Int64() 13705 if err != nil { 13706 return err 13707 } 13708 sv.RecordIndex = i64 13709 } 13710 13711 default: 13712 _, _ = key, value 13713 13714 } 13715 } 13716 *v = sv 13717 return nil 13718} 13719 13720func awsRestjson1_deserializeDocumentRecords(v *[]types.Record, value interface{}) error { 13721 if v == nil { 13722 return fmt.Errorf("unexpected nil of type %T", v) 13723 } 13724 if value == nil { 13725 return nil 13726 } 13727 13728 shape, ok := value.([]interface{}) 13729 if !ok { 13730 return fmt.Errorf("unexpected JSON type %v", value) 13731 } 13732 13733 var cv []types.Record 13734 if *v == nil { 13735 cv = []types.Record{} 13736 } else { 13737 cv = *v 13738 } 13739 13740 for _, value := range shape { 13741 var col types.Record 13742 destAddr := &col 13743 if err := awsRestjson1_deserializeDocumentRecord(&destAddr, value); err != nil { 13744 return err 13745 } 13746 col = *destAddr 13747 cv = append(cv, col) 13748 13749 } 13750 *v = cv 13751 return nil 13752} 13753 13754func awsRestjson1_deserializeDocumentReplicationDetails(v **types.ReplicationDetails, value interface{}) error { 13755 if v == nil { 13756 return fmt.Errorf("unexpected nil of type %T", v) 13757 } 13758 if value == nil { 13759 return nil 13760 } 13761 13762 shape, ok := value.(map[string]interface{}) 13763 if !ok { 13764 return fmt.Errorf("unexpected JSON type %v", value) 13765 } 13766 13767 var sv *types.ReplicationDetails 13768 if *v == nil { 13769 sv = &types.ReplicationDetails{} 13770 } else { 13771 sv = *v 13772 } 13773 13774 for key, value := range shape { 13775 switch key { 13776 case "replicated": 13777 if value != nil { 13778 jtv, ok := value.(bool) 13779 if !ok { 13780 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 13781 } 13782 sv.Replicated = jtv 13783 } 13784 13785 case "replicatedExternally": 13786 if value != nil { 13787 jtv, ok := value.(bool) 13788 if !ok { 13789 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 13790 } 13791 sv.ReplicatedExternally = jtv 13792 } 13793 13794 case "replicationAccounts": 13795 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.ReplicationAccounts, value); err != nil { 13796 return err 13797 } 13798 13799 default: 13800 _, _ = key, value 13801 13802 } 13803 } 13804 *v = sv 13805 return nil 13806} 13807 13808func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 13809 if v == nil { 13810 return fmt.Errorf("unexpected nil of type %T", v) 13811 } 13812 if value == nil { 13813 return nil 13814 } 13815 13816 shape, ok := value.(map[string]interface{}) 13817 if !ok { 13818 return fmt.Errorf("unexpected JSON type %v", value) 13819 } 13820 13821 var sv *types.ResourceNotFoundException 13822 if *v == nil { 13823 sv = &types.ResourceNotFoundException{} 13824 } else { 13825 sv = *v 13826 } 13827 13828 for key, value := range shape { 13829 switch key { 13830 case "message": 13831 if value != nil { 13832 jtv, ok := value.(string) 13833 if !ok { 13834 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13835 } 13836 sv.Message = ptr.String(jtv) 13837 } 13838 13839 default: 13840 _, _ = key, value 13841 13842 } 13843 } 13844 *v = sv 13845 return nil 13846} 13847 13848func awsRestjson1_deserializeDocumentResourcesAffected(v **types.ResourcesAffected, value interface{}) error { 13849 if v == nil { 13850 return fmt.Errorf("unexpected nil of type %T", v) 13851 } 13852 if value == nil { 13853 return nil 13854 } 13855 13856 shape, ok := value.(map[string]interface{}) 13857 if !ok { 13858 return fmt.Errorf("unexpected JSON type %v", value) 13859 } 13860 13861 var sv *types.ResourcesAffected 13862 if *v == nil { 13863 sv = &types.ResourcesAffected{} 13864 } else { 13865 sv = *v 13866 } 13867 13868 for key, value := range shape { 13869 switch key { 13870 case "s3Bucket": 13871 if err := awsRestjson1_deserializeDocumentS3Bucket(&sv.S3Bucket, value); err != nil { 13872 return err 13873 } 13874 13875 case "s3Object": 13876 if err := awsRestjson1_deserializeDocumentS3Object(&sv.S3Object, value); err != nil { 13877 return err 13878 } 13879 13880 default: 13881 _, _ = key, value 13882 13883 } 13884 } 13885 *v = sv 13886 return nil 13887} 13888 13889func awsRestjson1_deserializeDocumentS3Bucket(v **types.S3Bucket, value interface{}) error { 13890 if v == nil { 13891 return fmt.Errorf("unexpected nil of type %T", v) 13892 } 13893 if value == nil { 13894 return nil 13895 } 13896 13897 shape, ok := value.(map[string]interface{}) 13898 if !ok { 13899 return fmt.Errorf("unexpected JSON type %v", value) 13900 } 13901 13902 var sv *types.S3Bucket 13903 if *v == nil { 13904 sv = &types.S3Bucket{} 13905 } else { 13906 sv = *v 13907 } 13908 13909 for key, value := range shape { 13910 switch key { 13911 case "allowsUnencryptedObjectUploads": 13912 if value != nil { 13913 jtv, ok := value.(string) 13914 if !ok { 13915 return fmt.Errorf("expected AllowsUnencryptedObjectUploads to be of type string, got %T instead", value) 13916 } 13917 sv.AllowsUnencryptedObjectUploads = types.AllowsUnencryptedObjectUploads(jtv) 13918 } 13919 13920 case "arn": 13921 if value != nil { 13922 jtv, ok := value.(string) 13923 if !ok { 13924 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13925 } 13926 sv.Arn = ptr.String(jtv) 13927 } 13928 13929 case "createdAt": 13930 if value != nil { 13931 jtv, ok := value.(string) 13932 if !ok { 13933 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 13934 } 13935 t, err := smithytime.ParseDateTime(jtv) 13936 if err != nil { 13937 return err 13938 } 13939 sv.CreatedAt = ptr.Time(t) 13940 } 13941 13942 case "defaultServerSideEncryption": 13943 if err := awsRestjson1_deserializeDocumentServerSideEncryption(&sv.DefaultServerSideEncryption, value); err != nil { 13944 return err 13945 } 13946 13947 case "name": 13948 if value != nil { 13949 jtv, ok := value.(string) 13950 if !ok { 13951 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13952 } 13953 sv.Name = ptr.String(jtv) 13954 } 13955 13956 case "owner": 13957 if err := awsRestjson1_deserializeDocumentS3BucketOwner(&sv.Owner, value); err != nil { 13958 return err 13959 } 13960 13961 case "publicAccess": 13962 if err := awsRestjson1_deserializeDocumentBucketPublicAccess(&sv.PublicAccess, value); err != nil { 13963 return err 13964 } 13965 13966 case "tags": 13967 if err := awsRestjson1_deserializeDocumentKeyValuePairList(&sv.Tags, value); err != nil { 13968 return err 13969 } 13970 13971 default: 13972 _, _ = key, value 13973 13974 } 13975 } 13976 *v = sv 13977 return nil 13978} 13979 13980func awsRestjson1_deserializeDocumentS3BucketDefinitionForJob(v **types.S3BucketDefinitionForJob, value interface{}) error { 13981 if v == nil { 13982 return fmt.Errorf("unexpected nil of type %T", v) 13983 } 13984 if value == nil { 13985 return nil 13986 } 13987 13988 shape, ok := value.(map[string]interface{}) 13989 if !ok { 13990 return fmt.Errorf("unexpected JSON type %v", value) 13991 } 13992 13993 var sv *types.S3BucketDefinitionForJob 13994 if *v == nil { 13995 sv = &types.S3BucketDefinitionForJob{} 13996 } else { 13997 sv = *v 13998 } 13999 14000 for key, value := range shape { 14001 switch key { 14002 case "accountId": 14003 if value != nil { 14004 jtv, ok := value.(string) 14005 if !ok { 14006 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14007 } 14008 sv.AccountId = ptr.String(jtv) 14009 } 14010 14011 case "buckets": 14012 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Buckets, value); err != nil { 14013 return err 14014 } 14015 14016 default: 14017 _, _ = key, value 14018 14019 } 14020 } 14021 *v = sv 14022 return nil 14023} 14024 14025func awsRestjson1_deserializeDocumentS3BucketOwner(v **types.S3BucketOwner, 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.S3BucketOwner 14039 if *v == nil { 14040 sv = &types.S3BucketOwner{} 14041 } else { 14042 sv = *v 14043 } 14044 14045 for key, value := range shape { 14046 switch key { 14047 case "displayName": 14048 if value != nil { 14049 jtv, ok := value.(string) 14050 if !ok { 14051 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14052 } 14053 sv.DisplayName = ptr.String(jtv) 14054 } 14055 14056 case "id": 14057 if value != nil { 14058 jtv, ok := value.(string) 14059 if !ok { 14060 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14061 } 14062 sv.Id = ptr.String(jtv) 14063 } 14064 14065 default: 14066 _, _ = key, value 14067 14068 } 14069 } 14070 *v = sv 14071 return nil 14072} 14073 14074func awsRestjson1_deserializeDocumentS3Destination(v **types.S3Destination, value interface{}) error { 14075 if v == nil { 14076 return fmt.Errorf("unexpected nil of type %T", v) 14077 } 14078 if value == nil { 14079 return nil 14080 } 14081 14082 shape, ok := value.(map[string]interface{}) 14083 if !ok { 14084 return fmt.Errorf("unexpected JSON type %v", value) 14085 } 14086 14087 var sv *types.S3Destination 14088 if *v == nil { 14089 sv = &types.S3Destination{} 14090 } else { 14091 sv = *v 14092 } 14093 14094 for key, value := range shape { 14095 switch key { 14096 case "bucketName": 14097 if value != nil { 14098 jtv, ok := value.(string) 14099 if !ok { 14100 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14101 } 14102 sv.BucketName = ptr.String(jtv) 14103 } 14104 14105 case "keyPrefix": 14106 if value != nil { 14107 jtv, ok := value.(string) 14108 if !ok { 14109 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14110 } 14111 sv.KeyPrefix = ptr.String(jtv) 14112 } 14113 14114 case "kmsKeyArn": 14115 if value != nil { 14116 jtv, ok := value.(string) 14117 if !ok { 14118 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14119 } 14120 sv.KmsKeyArn = ptr.String(jtv) 14121 } 14122 14123 default: 14124 _, _ = key, value 14125 14126 } 14127 } 14128 *v = sv 14129 return nil 14130} 14131 14132func awsRestjson1_deserializeDocumentS3JobDefinition(v **types.S3JobDefinition, 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.S3JobDefinition 14146 if *v == nil { 14147 sv = &types.S3JobDefinition{} 14148 } else { 14149 sv = *v 14150 } 14151 14152 for key, value := range shape { 14153 switch key { 14154 case "bucketDefinitions": 14155 if err := awsRestjson1_deserializeDocument__listOfS3BucketDefinitionForJob(&sv.BucketDefinitions, value); err != nil { 14156 return err 14157 } 14158 14159 case "scoping": 14160 if err := awsRestjson1_deserializeDocumentScoping(&sv.Scoping, value); err != nil { 14161 return err 14162 } 14163 14164 default: 14165 _, _ = key, value 14166 14167 } 14168 } 14169 *v = sv 14170 return nil 14171} 14172 14173func awsRestjson1_deserializeDocumentS3Object(v **types.S3Object, value interface{}) error { 14174 if v == nil { 14175 return fmt.Errorf("unexpected nil of type %T", v) 14176 } 14177 if value == nil { 14178 return nil 14179 } 14180 14181 shape, ok := value.(map[string]interface{}) 14182 if !ok { 14183 return fmt.Errorf("unexpected JSON type %v", value) 14184 } 14185 14186 var sv *types.S3Object 14187 if *v == nil { 14188 sv = &types.S3Object{} 14189 } else { 14190 sv = *v 14191 } 14192 14193 for key, value := range shape { 14194 switch key { 14195 case "bucketArn": 14196 if value != nil { 14197 jtv, ok := value.(string) 14198 if !ok { 14199 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14200 } 14201 sv.BucketArn = ptr.String(jtv) 14202 } 14203 14204 case "eTag": 14205 if value != nil { 14206 jtv, ok := value.(string) 14207 if !ok { 14208 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14209 } 14210 sv.ETag = ptr.String(jtv) 14211 } 14212 14213 case "extension": 14214 if value != nil { 14215 jtv, ok := value.(string) 14216 if !ok { 14217 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14218 } 14219 sv.Extension = ptr.String(jtv) 14220 } 14221 14222 case "key": 14223 if value != nil { 14224 jtv, ok := value.(string) 14225 if !ok { 14226 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14227 } 14228 sv.Key = ptr.String(jtv) 14229 } 14230 14231 case "lastModified": 14232 if value != nil { 14233 jtv, ok := value.(string) 14234 if !ok { 14235 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 14236 } 14237 t, err := smithytime.ParseDateTime(jtv) 14238 if err != nil { 14239 return err 14240 } 14241 sv.LastModified = ptr.Time(t) 14242 } 14243 14244 case "path": 14245 if value != nil { 14246 jtv, ok := value.(string) 14247 if !ok { 14248 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14249 } 14250 sv.Path = ptr.String(jtv) 14251 } 14252 14253 case "publicAccess": 14254 if value != nil { 14255 jtv, ok := value.(bool) 14256 if !ok { 14257 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 14258 } 14259 sv.PublicAccess = jtv 14260 } 14261 14262 case "serverSideEncryption": 14263 if err := awsRestjson1_deserializeDocumentServerSideEncryption(&sv.ServerSideEncryption, value); err != nil { 14264 return err 14265 } 14266 14267 case "size": 14268 if value != nil { 14269 jtv, ok := value.(json.Number) 14270 if !ok { 14271 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 14272 } 14273 i64, err := jtv.Int64() 14274 if err != nil { 14275 return err 14276 } 14277 sv.Size = i64 14278 } 14279 14280 case "storageClass": 14281 if value != nil { 14282 jtv, ok := value.(string) 14283 if !ok { 14284 return fmt.Errorf("expected StorageClass to be of type string, got %T instead", value) 14285 } 14286 sv.StorageClass = types.StorageClass(jtv) 14287 } 14288 14289 case "tags": 14290 if err := awsRestjson1_deserializeDocumentKeyValuePairList(&sv.Tags, value); err != nil { 14291 return err 14292 } 14293 14294 case "versionId": 14295 if value != nil { 14296 jtv, ok := value.(string) 14297 if !ok { 14298 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14299 } 14300 sv.VersionId = ptr.String(jtv) 14301 } 14302 14303 default: 14304 _, _ = key, value 14305 14306 } 14307 } 14308 *v = sv 14309 return nil 14310} 14311 14312func awsRestjson1_deserializeDocumentScoping(v **types.Scoping, value interface{}) error { 14313 if v == nil { 14314 return fmt.Errorf("unexpected nil of type %T", v) 14315 } 14316 if value == nil { 14317 return nil 14318 } 14319 14320 shape, ok := value.(map[string]interface{}) 14321 if !ok { 14322 return fmt.Errorf("unexpected JSON type %v", value) 14323 } 14324 14325 var sv *types.Scoping 14326 if *v == nil { 14327 sv = &types.Scoping{} 14328 } else { 14329 sv = *v 14330 } 14331 14332 for key, value := range shape { 14333 switch key { 14334 case "excludes": 14335 if err := awsRestjson1_deserializeDocumentJobScopingBlock(&sv.Excludes, value); err != nil { 14336 return err 14337 } 14338 14339 case "includes": 14340 if err := awsRestjson1_deserializeDocumentJobScopingBlock(&sv.Includes, value); err != nil { 14341 return err 14342 } 14343 14344 default: 14345 _, _ = key, value 14346 14347 } 14348 } 14349 *v = sv 14350 return nil 14351} 14352 14353func awsRestjson1_deserializeDocumentSecurityHubConfiguration(v **types.SecurityHubConfiguration, value interface{}) error { 14354 if v == nil { 14355 return fmt.Errorf("unexpected nil of type %T", v) 14356 } 14357 if value == nil { 14358 return nil 14359 } 14360 14361 shape, ok := value.(map[string]interface{}) 14362 if !ok { 14363 return fmt.Errorf("unexpected JSON type %v", value) 14364 } 14365 14366 var sv *types.SecurityHubConfiguration 14367 if *v == nil { 14368 sv = &types.SecurityHubConfiguration{} 14369 } else { 14370 sv = *v 14371 } 14372 14373 for key, value := range shape { 14374 switch key { 14375 case "publishClassificationFindings": 14376 if value != nil { 14377 jtv, ok := value.(bool) 14378 if !ok { 14379 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 14380 } 14381 sv.PublishClassificationFindings = jtv 14382 } 14383 14384 case "publishPolicyFindings": 14385 if value != nil { 14386 jtv, ok := value.(bool) 14387 if !ok { 14388 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 14389 } 14390 sv.PublishPolicyFindings = jtv 14391 } 14392 14393 default: 14394 _, _ = key, value 14395 14396 } 14397 } 14398 *v = sv 14399 return nil 14400} 14401 14402func awsRestjson1_deserializeDocumentSensitiveData(v *[]types.SensitiveDataItem, value interface{}) error { 14403 if v == nil { 14404 return fmt.Errorf("unexpected nil of type %T", v) 14405 } 14406 if value == nil { 14407 return nil 14408 } 14409 14410 shape, ok := value.([]interface{}) 14411 if !ok { 14412 return fmt.Errorf("unexpected JSON type %v", value) 14413 } 14414 14415 var cv []types.SensitiveDataItem 14416 if *v == nil { 14417 cv = []types.SensitiveDataItem{} 14418 } else { 14419 cv = *v 14420 } 14421 14422 for _, value := range shape { 14423 var col types.SensitiveDataItem 14424 destAddr := &col 14425 if err := awsRestjson1_deserializeDocumentSensitiveDataItem(&destAddr, value); err != nil { 14426 return err 14427 } 14428 col = *destAddr 14429 cv = append(cv, col) 14430 14431 } 14432 *v = cv 14433 return nil 14434} 14435 14436func awsRestjson1_deserializeDocumentSensitiveDataItem(v **types.SensitiveDataItem, value interface{}) error { 14437 if v == nil { 14438 return fmt.Errorf("unexpected nil of type %T", v) 14439 } 14440 if value == nil { 14441 return nil 14442 } 14443 14444 shape, ok := value.(map[string]interface{}) 14445 if !ok { 14446 return fmt.Errorf("unexpected JSON type %v", value) 14447 } 14448 14449 var sv *types.SensitiveDataItem 14450 if *v == nil { 14451 sv = &types.SensitiveDataItem{} 14452 } else { 14453 sv = *v 14454 } 14455 14456 for key, value := range shape { 14457 switch key { 14458 case "category": 14459 if value != nil { 14460 jtv, ok := value.(string) 14461 if !ok { 14462 return fmt.Errorf("expected SensitiveDataItemCategory to be of type string, got %T instead", value) 14463 } 14464 sv.Category = types.SensitiveDataItemCategory(jtv) 14465 } 14466 14467 case "detections": 14468 if err := awsRestjson1_deserializeDocumentDefaultDetections(&sv.Detections, value); err != nil { 14469 return err 14470 } 14471 14472 case "totalCount": 14473 if value != nil { 14474 jtv, ok := value.(json.Number) 14475 if !ok { 14476 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 14477 } 14478 i64, err := jtv.Int64() 14479 if err != nil { 14480 return err 14481 } 14482 sv.TotalCount = i64 14483 } 14484 14485 default: 14486 _, _ = key, value 14487 14488 } 14489 } 14490 *v = sv 14491 return nil 14492} 14493 14494func awsRestjson1_deserializeDocumentServerSideEncryption(v **types.ServerSideEncryption, value interface{}) error { 14495 if v == nil { 14496 return fmt.Errorf("unexpected nil of type %T", v) 14497 } 14498 if value == nil { 14499 return nil 14500 } 14501 14502 shape, ok := value.(map[string]interface{}) 14503 if !ok { 14504 return fmt.Errorf("unexpected JSON type %v", value) 14505 } 14506 14507 var sv *types.ServerSideEncryption 14508 if *v == nil { 14509 sv = &types.ServerSideEncryption{} 14510 } else { 14511 sv = *v 14512 } 14513 14514 for key, value := range shape { 14515 switch key { 14516 case "encryptionType": 14517 if value != nil { 14518 jtv, ok := value.(string) 14519 if !ok { 14520 return fmt.Errorf("expected EncryptionType to be of type string, got %T instead", value) 14521 } 14522 sv.EncryptionType = types.EncryptionType(jtv) 14523 } 14524 14525 case "kmsMasterKeyId": 14526 if value != nil { 14527 jtv, ok := value.(string) 14528 if !ok { 14529 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14530 } 14531 sv.KmsMasterKeyId = ptr.String(jtv) 14532 } 14533 14534 default: 14535 _, _ = key, value 14536 14537 } 14538 } 14539 *v = sv 14540 return nil 14541} 14542 14543func awsRestjson1_deserializeDocumentServiceLimit(v **types.ServiceLimit, value interface{}) error { 14544 if v == nil { 14545 return fmt.Errorf("unexpected nil of type %T", v) 14546 } 14547 if value == nil { 14548 return nil 14549 } 14550 14551 shape, ok := value.(map[string]interface{}) 14552 if !ok { 14553 return fmt.Errorf("unexpected JSON type %v", value) 14554 } 14555 14556 var sv *types.ServiceLimit 14557 if *v == nil { 14558 sv = &types.ServiceLimit{} 14559 } else { 14560 sv = *v 14561 } 14562 14563 for key, value := range shape { 14564 switch key { 14565 case "isServiceLimited": 14566 if value != nil { 14567 jtv, ok := value.(bool) 14568 if !ok { 14569 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 14570 } 14571 sv.IsServiceLimited = jtv 14572 } 14573 14574 case "unit": 14575 if value != nil { 14576 jtv, ok := value.(string) 14577 if !ok { 14578 return fmt.Errorf("expected Unit to be of type string, got %T instead", value) 14579 } 14580 sv.Unit = types.Unit(jtv) 14581 } 14582 14583 case "value": 14584 if value != nil { 14585 jtv, ok := value.(json.Number) 14586 if !ok { 14587 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 14588 } 14589 i64, err := jtv.Int64() 14590 if err != nil { 14591 return err 14592 } 14593 sv.Value = i64 14594 } 14595 14596 default: 14597 _, _ = key, value 14598 14599 } 14600 } 14601 *v = sv 14602 return nil 14603} 14604 14605func awsRestjson1_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error { 14606 if v == nil { 14607 return fmt.Errorf("unexpected nil of type %T", v) 14608 } 14609 if value == nil { 14610 return nil 14611 } 14612 14613 shape, ok := value.(map[string]interface{}) 14614 if !ok { 14615 return fmt.Errorf("unexpected JSON type %v", value) 14616 } 14617 14618 var sv *types.ServiceQuotaExceededException 14619 if *v == nil { 14620 sv = &types.ServiceQuotaExceededException{} 14621 } else { 14622 sv = *v 14623 } 14624 14625 for key, value := range shape { 14626 switch key { 14627 case "message": 14628 if value != nil { 14629 jtv, ok := value.(string) 14630 if !ok { 14631 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14632 } 14633 sv.Message = ptr.String(jtv) 14634 } 14635 14636 default: 14637 _, _ = key, value 14638 14639 } 14640 } 14641 *v = sv 14642 return nil 14643} 14644 14645func awsRestjson1_deserializeDocumentSessionContext(v **types.SessionContext, value interface{}) error { 14646 if v == nil { 14647 return fmt.Errorf("unexpected nil of type %T", v) 14648 } 14649 if value == nil { 14650 return nil 14651 } 14652 14653 shape, ok := value.(map[string]interface{}) 14654 if !ok { 14655 return fmt.Errorf("unexpected JSON type %v", value) 14656 } 14657 14658 var sv *types.SessionContext 14659 if *v == nil { 14660 sv = &types.SessionContext{} 14661 } else { 14662 sv = *v 14663 } 14664 14665 for key, value := range shape { 14666 switch key { 14667 case "attributes": 14668 if err := awsRestjson1_deserializeDocumentSessionContextAttributes(&sv.Attributes, value); err != nil { 14669 return err 14670 } 14671 14672 case "sessionIssuer": 14673 if err := awsRestjson1_deserializeDocumentSessionIssuer(&sv.SessionIssuer, value); err != nil { 14674 return err 14675 } 14676 14677 default: 14678 _, _ = key, value 14679 14680 } 14681 } 14682 *v = sv 14683 return nil 14684} 14685 14686func awsRestjson1_deserializeDocumentSessionContextAttributes(v **types.SessionContextAttributes, value interface{}) error { 14687 if v == nil { 14688 return fmt.Errorf("unexpected nil of type %T", v) 14689 } 14690 if value == nil { 14691 return nil 14692 } 14693 14694 shape, ok := value.(map[string]interface{}) 14695 if !ok { 14696 return fmt.Errorf("unexpected JSON type %v", value) 14697 } 14698 14699 var sv *types.SessionContextAttributes 14700 if *v == nil { 14701 sv = &types.SessionContextAttributes{} 14702 } else { 14703 sv = *v 14704 } 14705 14706 for key, value := range shape { 14707 switch key { 14708 case "creationDate": 14709 if value != nil { 14710 jtv, ok := value.(string) 14711 if !ok { 14712 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 14713 } 14714 t, err := smithytime.ParseDateTime(jtv) 14715 if err != nil { 14716 return err 14717 } 14718 sv.CreationDate = ptr.Time(t) 14719 } 14720 14721 case "mfaAuthenticated": 14722 if value != nil { 14723 jtv, ok := value.(bool) 14724 if !ok { 14725 return fmt.Errorf("expected __boolean to be of type *bool, got %T instead", value) 14726 } 14727 sv.MfaAuthenticated = jtv 14728 } 14729 14730 default: 14731 _, _ = key, value 14732 14733 } 14734 } 14735 *v = sv 14736 return nil 14737} 14738 14739func awsRestjson1_deserializeDocumentSessionIssuer(v **types.SessionIssuer, value interface{}) error { 14740 if v == nil { 14741 return fmt.Errorf("unexpected nil of type %T", v) 14742 } 14743 if value == nil { 14744 return nil 14745 } 14746 14747 shape, ok := value.(map[string]interface{}) 14748 if !ok { 14749 return fmt.Errorf("unexpected JSON type %v", value) 14750 } 14751 14752 var sv *types.SessionIssuer 14753 if *v == nil { 14754 sv = &types.SessionIssuer{} 14755 } else { 14756 sv = *v 14757 } 14758 14759 for key, value := range shape { 14760 switch key { 14761 case "accountId": 14762 if value != nil { 14763 jtv, ok := value.(string) 14764 if !ok { 14765 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14766 } 14767 sv.AccountId = ptr.String(jtv) 14768 } 14769 14770 case "arn": 14771 if value != nil { 14772 jtv, ok := value.(string) 14773 if !ok { 14774 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14775 } 14776 sv.Arn = ptr.String(jtv) 14777 } 14778 14779 case "principalId": 14780 if value != nil { 14781 jtv, ok := value.(string) 14782 if !ok { 14783 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14784 } 14785 sv.PrincipalId = ptr.String(jtv) 14786 } 14787 14788 case "type": 14789 if value != nil { 14790 jtv, ok := value.(string) 14791 if !ok { 14792 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14793 } 14794 sv.Type = ptr.String(jtv) 14795 } 14796 14797 case "userName": 14798 if value != nil { 14799 jtv, ok := value.(string) 14800 if !ok { 14801 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14802 } 14803 sv.UserName = ptr.String(jtv) 14804 } 14805 14806 default: 14807 _, _ = key, value 14808 14809 } 14810 } 14811 *v = sv 14812 return nil 14813} 14814 14815func awsRestjson1_deserializeDocumentSeverity(v **types.Severity, value interface{}) error { 14816 if v == nil { 14817 return fmt.Errorf("unexpected nil of type %T", v) 14818 } 14819 if value == nil { 14820 return nil 14821 } 14822 14823 shape, ok := value.(map[string]interface{}) 14824 if !ok { 14825 return fmt.Errorf("unexpected JSON type %v", value) 14826 } 14827 14828 var sv *types.Severity 14829 if *v == nil { 14830 sv = &types.Severity{} 14831 } else { 14832 sv = *v 14833 } 14834 14835 for key, value := range shape { 14836 switch key { 14837 case "description": 14838 if value != nil { 14839 jtv, ok := value.(string) 14840 if !ok { 14841 return fmt.Errorf("expected SeverityDescription to be of type string, got %T instead", value) 14842 } 14843 sv.Description = types.SeverityDescription(jtv) 14844 } 14845 14846 case "score": 14847 if value != nil { 14848 jtv, ok := value.(json.Number) 14849 if !ok { 14850 return fmt.Errorf("expected __long to be json.Number, got %T instead", value) 14851 } 14852 i64, err := jtv.Int64() 14853 if err != nil { 14854 return err 14855 } 14856 sv.Score = i64 14857 } 14858 14859 default: 14860 _, _ = key, value 14861 14862 } 14863 } 14864 *v = sv 14865 return nil 14866} 14867 14868func awsRestjson1_deserializeDocumentSimpleScopeTerm(v **types.SimpleScopeTerm, value interface{}) error { 14869 if v == nil { 14870 return fmt.Errorf("unexpected nil of type %T", v) 14871 } 14872 if value == nil { 14873 return nil 14874 } 14875 14876 shape, ok := value.(map[string]interface{}) 14877 if !ok { 14878 return fmt.Errorf("unexpected JSON type %v", value) 14879 } 14880 14881 var sv *types.SimpleScopeTerm 14882 if *v == nil { 14883 sv = &types.SimpleScopeTerm{} 14884 } else { 14885 sv = *v 14886 } 14887 14888 for key, value := range shape { 14889 switch key { 14890 case "comparator": 14891 if value != nil { 14892 jtv, ok := value.(string) 14893 if !ok { 14894 return fmt.Errorf("expected JobComparator to be of type string, got %T instead", value) 14895 } 14896 sv.Comparator = types.JobComparator(jtv) 14897 } 14898 14899 case "key": 14900 if value != nil { 14901 jtv, ok := value.(string) 14902 if !ok { 14903 return fmt.Errorf("expected ScopeFilterKey to be of type string, got %T instead", value) 14904 } 14905 sv.Key = types.ScopeFilterKey(jtv) 14906 } 14907 14908 case "values": 14909 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Values, value); err != nil { 14910 return err 14911 } 14912 14913 default: 14914 _, _ = key, value 14915 14916 } 14917 } 14918 *v = sv 14919 return nil 14920} 14921 14922func awsRestjson1_deserializeDocumentStatistics(v **types.Statistics, value interface{}) error { 14923 if v == nil { 14924 return fmt.Errorf("unexpected nil of type %T", v) 14925 } 14926 if value == nil { 14927 return nil 14928 } 14929 14930 shape, ok := value.(map[string]interface{}) 14931 if !ok { 14932 return fmt.Errorf("unexpected JSON type %v", value) 14933 } 14934 14935 var sv *types.Statistics 14936 if *v == nil { 14937 sv = &types.Statistics{} 14938 } else { 14939 sv = *v 14940 } 14941 14942 for key, value := range shape { 14943 switch key { 14944 case "approximateNumberOfObjectsToProcess": 14945 if value != nil { 14946 jtv, ok := value.(json.Number) 14947 if !ok { 14948 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 14949 } 14950 f64, err := jtv.Float64() 14951 if err != nil { 14952 return err 14953 } 14954 sv.ApproximateNumberOfObjectsToProcess = f64 14955 } 14956 14957 case "numberOfRuns": 14958 if value != nil { 14959 jtv, ok := value.(json.Number) 14960 if !ok { 14961 return fmt.Errorf("expected __double to be json.Number, got %T instead", value) 14962 } 14963 f64, err := jtv.Float64() 14964 if err != nil { 14965 return err 14966 } 14967 sv.NumberOfRuns = f64 14968 } 14969 14970 default: 14971 _, _ = key, value 14972 14973 } 14974 } 14975 *v = sv 14976 return nil 14977} 14978 14979func awsRestjson1_deserializeDocumentTagMap(v *map[string]string, value interface{}) error { 14980 if v == nil { 14981 return fmt.Errorf("unexpected nil of type %T", v) 14982 } 14983 if value == nil { 14984 return nil 14985 } 14986 14987 shape, ok := value.(map[string]interface{}) 14988 if !ok { 14989 return fmt.Errorf("unexpected JSON type %v", value) 14990 } 14991 14992 var mv map[string]string 14993 if *v == nil { 14994 mv = map[string]string{} 14995 } else { 14996 mv = *v 14997 } 14998 14999 for key, value := range shape { 15000 var parsedVal string 15001 if value != nil { 15002 jtv, ok := value.(string) 15003 if !ok { 15004 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15005 } 15006 parsedVal = jtv 15007 } 15008 mv[key] = parsedVal 15009 15010 } 15011 *v = mv 15012 return nil 15013} 15014 15015func awsRestjson1_deserializeDocumentTagScopeTerm(v **types.TagScopeTerm, value interface{}) error { 15016 if v == nil { 15017 return fmt.Errorf("unexpected nil of type %T", v) 15018 } 15019 if value == nil { 15020 return nil 15021 } 15022 15023 shape, ok := value.(map[string]interface{}) 15024 if !ok { 15025 return fmt.Errorf("unexpected JSON type %v", value) 15026 } 15027 15028 var sv *types.TagScopeTerm 15029 if *v == nil { 15030 sv = &types.TagScopeTerm{} 15031 } else { 15032 sv = *v 15033 } 15034 15035 for key, value := range shape { 15036 switch key { 15037 case "comparator": 15038 if value != nil { 15039 jtv, ok := value.(string) 15040 if !ok { 15041 return fmt.Errorf("expected JobComparator to be of type string, got %T instead", value) 15042 } 15043 sv.Comparator = types.JobComparator(jtv) 15044 } 15045 15046 case "key": 15047 if value != nil { 15048 jtv, ok := value.(string) 15049 if !ok { 15050 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15051 } 15052 sv.Key = ptr.String(jtv) 15053 } 15054 15055 case "tagValues": 15056 if err := awsRestjson1_deserializeDocument__listOfTagValuePair(&sv.TagValues, value); err != nil { 15057 return err 15058 } 15059 15060 case "target": 15061 if value != nil { 15062 jtv, ok := value.(string) 15063 if !ok { 15064 return fmt.Errorf("expected TagTarget to be of type string, got %T instead", value) 15065 } 15066 sv.Target = types.TagTarget(jtv) 15067 } 15068 15069 default: 15070 _, _ = key, value 15071 15072 } 15073 } 15074 *v = sv 15075 return nil 15076} 15077 15078func awsRestjson1_deserializeDocumentTagValuePair(v **types.TagValuePair, value interface{}) error { 15079 if v == nil { 15080 return fmt.Errorf("unexpected nil of type %T", v) 15081 } 15082 if value == nil { 15083 return nil 15084 } 15085 15086 shape, ok := value.(map[string]interface{}) 15087 if !ok { 15088 return fmt.Errorf("unexpected JSON type %v", value) 15089 } 15090 15091 var sv *types.TagValuePair 15092 if *v == nil { 15093 sv = &types.TagValuePair{} 15094 } else { 15095 sv = *v 15096 } 15097 15098 for key, value := range shape { 15099 switch key { 15100 case "key": 15101 if value != nil { 15102 jtv, ok := value.(string) 15103 if !ok { 15104 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15105 } 15106 sv.Key = ptr.String(jtv) 15107 } 15108 15109 case "value": 15110 if value != nil { 15111 jtv, ok := value.(string) 15112 if !ok { 15113 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15114 } 15115 sv.Value = ptr.String(jtv) 15116 } 15117 15118 default: 15119 _, _ = key, value 15120 15121 } 15122 } 15123 *v = sv 15124 return nil 15125} 15126 15127func awsRestjson1_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 15128 if v == nil { 15129 return fmt.Errorf("unexpected nil of type %T", v) 15130 } 15131 if value == nil { 15132 return nil 15133 } 15134 15135 shape, ok := value.(map[string]interface{}) 15136 if !ok { 15137 return fmt.Errorf("unexpected JSON type %v", value) 15138 } 15139 15140 var sv *types.ThrottlingException 15141 if *v == nil { 15142 sv = &types.ThrottlingException{} 15143 } else { 15144 sv = *v 15145 } 15146 15147 for key, value := range shape { 15148 switch key { 15149 case "message": 15150 if value != nil { 15151 jtv, ok := value.(string) 15152 if !ok { 15153 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15154 } 15155 sv.Message = ptr.String(jtv) 15156 } 15157 15158 default: 15159 _, _ = key, value 15160 15161 } 15162 } 15163 *v = sv 15164 return nil 15165} 15166 15167func awsRestjson1_deserializeDocumentUnprocessedAccount(v **types.UnprocessedAccount, value interface{}) error { 15168 if v == nil { 15169 return fmt.Errorf("unexpected nil of type %T", v) 15170 } 15171 if value == nil { 15172 return nil 15173 } 15174 15175 shape, ok := value.(map[string]interface{}) 15176 if !ok { 15177 return fmt.Errorf("unexpected JSON type %v", value) 15178 } 15179 15180 var sv *types.UnprocessedAccount 15181 if *v == nil { 15182 sv = &types.UnprocessedAccount{} 15183 } else { 15184 sv = *v 15185 } 15186 15187 for key, value := range shape { 15188 switch key { 15189 case "accountId": 15190 if value != nil { 15191 jtv, ok := value.(string) 15192 if !ok { 15193 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15194 } 15195 sv.AccountId = ptr.String(jtv) 15196 } 15197 15198 case "errorCode": 15199 if value != nil { 15200 jtv, ok := value.(string) 15201 if !ok { 15202 return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value) 15203 } 15204 sv.ErrorCode = types.ErrorCode(jtv) 15205 } 15206 15207 case "errorMessage": 15208 if value != nil { 15209 jtv, ok := value.(string) 15210 if !ok { 15211 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15212 } 15213 sv.ErrorMessage = ptr.String(jtv) 15214 } 15215 15216 default: 15217 _, _ = key, value 15218 15219 } 15220 } 15221 *v = sv 15222 return nil 15223} 15224 15225func awsRestjson1_deserializeDocumentUsageByAccount(v **types.UsageByAccount, value interface{}) error { 15226 if v == nil { 15227 return fmt.Errorf("unexpected nil of type %T", v) 15228 } 15229 if value == nil { 15230 return nil 15231 } 15232 15233 shape, ok := value.(map[string]interface{}) 15234 if !ok { 15235 return fmt.Errorf("unexpected JSON type %v", value) 15236 } 15237 15238 var sv *types.UsageByAccount 15239 if *v == nil { 15240 sv = &types.UsageByAccount{} 15241 } else { 15242 sv = *v 15243 } 15244 15245 for key, value := range shape { 15246 switch key { 15247 case "currency": 15248 if value != nil { 15249 jtv, ok := value.(string) 15250 if !ok { 15251 return fmt.Errorf("expected Currency to be of type string, got %T instead", value) 15252 } 15253 sv.Currency = types.Currency(jtv) 15254 } 15255 15256 case "estimatedCost": 15257 if value != nil { 15258 jtv, ok := value.(string) 15259 if !ok { 15260 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15261 } 15262 sv.EstimatedCost = ptr.String(jtv) 15263 } 15264 15265 case "serviceLimit": 15266 if err := awsRestjson1_deserializeDocumentServiceLimit(&sv.ServiceLimit, value); err != nil { 15267 return err 15268 } 15269 15270 case "type": 15271 if value != nil { 15272 jtv, ok := value.(string) 15273 if !ok { 15274 return fmt.Errorf("expected UsageType to be of type string, got %T instead", value) 15275 } 15276 sv.Type = types.UsageType(jtv) 15277 } 15278 15279 default: 15280 _, _ = key, value 15281 15282 } 15283 } 15284 *v = sv 15285 return nil 15286} 15287 15288func awsRestjson1_deserializeDocumentUsageRecord(v **types.UsageRecord, value interface{}) error { 15289 if v == nil { 15290 return fmt.Errorf("unexpected nil of type %T", v) 15291 } 15292 if value == nil { 15293 return nil 15294 } 15295 15296 shape, ok := value.(map[string]interface{}) 15297 if !ok { 15298 return fmt.Errorf("unexpected JSON type %v", value) 15299 } 15300 15301 var sv *types.UsageRecord 15302 if *v == nil { 15303 sv = &types.UsageRecord{} 15304 } else { 15305 sv = *v 15306 } 15307 15308 for key, value := range shape { 15309 switch key { 15310 case "accountId": 15311 if value != nil { 15312 jtv, ok := value.(string) 15313 if !ok { 15314 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15315 } 15316 sv.AccountId = ptr.String(jtv) 15317 } 15318 15319 case "freeTrialStartDate": 15320 if value != nil { 15321 jtv, ok := value.(string) 15322 if !ok { 15323 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 15324 } 15325 t, err := smithytime.ParseDateTime(jtv) 15326 if err != nil { 15327 return err 15328 } 15329 sv.FreeTrialStartDate = ptr.Time(t) 15330 } 15331 15332 case "usage": 15333 if err := awsRestjson1_deserializeDocument__listOfUsageByAccount(&sv.Usage, value); err != nil { 15334 return err 15335 } 15336 15337 default: 15338 _, _ = key, value 15339 15340 } 15341 } 15342 *v = sv 15343 return nil 15344} 15345 15346func awsRestjson1_deserializeDocumentUsageTotal(v **types.UsageTotal, value interface{}) error { 15347 if v == nil { 15348 return fmt.Errorf("unexpected nil of type %T", v) 15349 } 15350 if value == nil { 15351 return nil 15352 } 15353 15354 shape, ok := value.(map[string]interface{}) 15355 if !ok { 15356 return fmt.Errorf("unexpected JSON type %v", value) 15357 } 15358 15359 var sv *types.UsageTotal 15360 if *v == nil { 15361 sv = &types.UsageTotal{} 15362 } else { 15363 sv = *v 15364 } 15365 15366 for key, value := range shape { 15367 switch key { 15368 case "currency": 15369 if value != nil { 15370 jtv, ok := value.(string) 15371 if !ok { 15372 return fmt.Errorf("expected Currency to be of type string, got %T instead", value) 15373 } 15374 sv.Currency = types.Currency(jtv) 15375 } 15376 15377 case "estimatedCost": 15378 if value != nil { 15379 jtv, ok := value.(string) 15380 if !ok { 15381 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15382 } 15383 sv.EstimatedCost = ptr.String(jtv) 15384 } 15385 15386 case "type": 15387 if value != nil { 15388 jtv, ok := value.(string) 15389 if !ok { 15390 return fmt.Errorf("expected UsageType to be of type string, got %T instead", value) 15391 } 15392 sv.Type = types.UsageType(jtv) 15393 } 15394 15395 default: 15396 _, _ = key, value 15397 15398 } 15399 } 15400 *v = sv 15401 return nil 15402} 15403 15404func awsRestjson1_deserializeDocumentUserIdentity(v **types.UserIdentity, value interface{}) error { 15405 if v == nil { 15406 return fmt.Errorf("unexpected nil of type %T", v) 15407 } 15408 if value == nil { 15409 return nil 15410 } 15411 15412 shape, ok := value.(map[string]interface{}) 15413 if !ok { 15414 return fmt.Errorf("unexpected JSON type %v", value) 15415 } 15416 15417 var sv *types.UserIdentity 15418 if *v == nil { 15419 sv = &types.UserIdentity{} 15420 } else { 15421 sv = *v 15422 } 15423 15424 for key, value := range shape { 15425 switch key { 15426 case "assumedRole": 15427 if err := awsRestjson1_deserializeDocumentAssumedRole(&sv.AssumedRole, value); err != nil { 15428 return err 15429 } 15430 15431 case "awsAccount": 15432 if err := awsRestjson1_deserializeDocumentAwsAccount(&sv.AwsAccount, value); err != nil { 15433 return err 15434 } 15435 15436 case "awsService": 15437 if err := awsRestjson1_deserializeDocumentAwsService(&sv.AwsService, value); err != nil { 15438 return err 15439 } 15440 15441 case "federatedUser": 15442 if err := awsRestjson1_deserializeDocumentFederatedUser(&sv.FederatedUser, value); err != nil { 15443 return err 15444 } 15445 15446 case "iamUser": 15447 if err := awsRestjson1_deserializeDocumentIamUser(&sv.IamUser, value); err != nil { 15448 return err 15449 } 15450 15451 case "root": 15452 if err := awsRestjson1_deserializeDocumentUserIdentityRoot(&sv.Root, value); err != nil { 15453 return err 15454 } 15455 15456 case "type": 15457 if value != nil { 15458 jtv, ok := value.(string) 15459 if !ok { 15460 return fmt.Errorf("expected UserIdentityType to be of type string, got %T instead", value) 15461 } 15462 sv.Type = types.UserIdentityType(jtv) 15463 } 15464 15465 default: 15466 _, _ = key, value 15467 15468 } 15469 } 15470 *v = sv 15471 return nil 15472} 15473 15474func awsRestjson1_deserializeDocumentUserIdentityRoot(v **types.UserIdentityRoot, value interface{}) error { 15475 if v == nil { 15476 return fmt.Errorf("unexpected nil of type %T", v) 15477 } 15478 if value == nil { 15479 return nil 15480 } 15481 15482 shape, ok := value.(map[string]interface{}) 15483 if !ok { 15484 return fmt.Errorf("unexpected JSON type %v", value) 15485 } 15486 15487 var sv *types.UserIdentityRoot 15488 if *v == nil { 15489 sv = &types.UserIdentityRoot{} 15490 } else { 15491 sv = *v 15492 } 15493 15494 for key, value := range shape { 15495 switch key { 15496 case "accountId": 15497 if value != nil { 15498 jtv, ok := value.(string) 15499 if !ok { 15500 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15501 } 15502 sv.AccountId = ptr.String(jtv) 15503 } 15504 15505 case "arn": 15506 if value != nil { 15507 jtv, ok := value.(string) 15508 if !ok { 15509 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15510 } 15511 sv.Arn = ptr.String(jtv) 15512 } 15513 15514 case "principalId": 15515 if value != nil { 15516 jtv, ok := value.(string) 15517 if !ok { 15518 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15519 } 15520 sv.PrincipalId = ptr.String(jtv) 15521 } 15522 15523 default: 15524 _, _ = key, value 15525 15526 } 15527 } 15528 *v = sv 15529 return nil 15530} 15531 15532func awsRestjson1_deserializeDocumentUserPausedDetails(v **types.UserPausedDetails, value interface{}) error { 15533 if v == nil { 15534 return fmt.Errorf("unexpected nil of type %T", v) 15535 } 15536 if value == nil { 15537 return nil 15538 } 15539 15540 shape, ok := value.(map[string]interface{}) 15541 if !ok { 15542 return fmt.Errorf("unexpected JSON type %v", value) 15543 } 15544 15545 var sv *types.UserPausedDetails 15546 if *v == nil { 15547 sv = &types.UserPausedDetails{} 15548 } else { 15549 sv = *v 15550 } 15551 15552 for key, value := range shape { 15553 switch key { 15554 case "jobExpiresAt": 15555 if value != nil { 15556 jtv, ok := value.(string) 15557 if !ok { 15558 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 15559 } 15560 t, err := smithytime.ParseDateTime(jtv) 15561 if err != nil { 15562 return err 15563 } 15564 sv.JobExpiresAt = ptr.Time(t) 15565 } 15566 15567 case "jobImminentExpirationHealthEventArn": 15568 if value != nil { 15569 jtv, ok := value.(string) 15570 if !ok { 15571 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15572 } 15573 sv.JobImminentExpirationHealthEventArn = ptr.String(jtv) 15574 } 15575 15576 case "jobPausedAt": 15577 if value != nil { 15578 jtv, ok := value.(string) 15579 if !ok { 15580 return fmt.Errorf("expected __timestampIso8601 to be of type string, got %T instead", value) 15581 } 15582 t, err := smithytime.ParseDateTime(jtv) 15583 if err != nil { 15584 return err 15585 } 15586 sv.JobPausedAt = ptr.Time(t) 15587 } 15588 15589 default: 15590 _, _ = key, value 15591 15592 } 15593 } 15594 *v = sv 15595 return nil 15596} 15597 15598func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 15599 if v == nil { 15600 return fmt.Errorf("unexpected nil of type %T", v) 15601 } 15602 if value == nil { 15603 return nil 15604 } 15605 15606 shape, ok := value.(map[string]interface{}) 15607 if !ok { 15608 return fmt.Errorf("unexpected JSON type %v", value) 15609 } 15610 15611 var sv *types.ValidationException 15612 if *v == nil { 15613 sv = &types.ValidationException{} 15614 } else { 15615 sv = *v 15616 } 15617 15618 for key, value := range shape { 15619 switch key { 15620 case "message": 15621 if value != nil { 15622 jtv, ok := value.(string) 15623 if !ok { 15624 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15625 } 15626 sv.Message = ptr.String(jtv) 15627 } 15628 15629 default: 15630 _, _ = key, value 15631 15632 } 15633 } 15634 *v = sv 15635 return nil 15636} 15637 15638func awsRestjson1_deserializeDocumentWeeklySchedule(v **types.WeeklySchedule, value interface{}) error { 15639 if v == nil { 15640 return fmt.Errorf("unexpected nil of type %T", v) 15641 } 15642 if value == nil { 15643 return nil 15644 } 15645 15646 shape, ok := value.(map[string]interface{}) 15647 if !ok { 15648 return fmt.Errorf("unexpected JSON type %v", value) 15649 } 15650 15651 var sv *types.WeeklySchedule 15652 if *v == nil { 15653 sv = &types.WeeklySchedule{} 15654 } else { 15655 sv = *v 15656 } 15657 15658 for key, value := range shape { 15659 switch key { 15660 case "dayOfWeek": 15661 if value != nil { 15662 jtv, ok := value.(string) 15663 if !ok { 15664 return fmt.Errorf("expected DayOfWeek to be of type string, got %T instead", value) 15665 } 15666 sv.DayOfWeek = types.DayOfWeek(jtv) 15667 } 15668 15669 default: 15670 _, _ = key, value 15671 15672 } 15673 } 15674 *v = sv 15675 return nil 15676} 15677