1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package customerprofiles 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/customerprofiles/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_deserializeOpAddProfileKey struct { 23} 24 25func (*awsRestjson1_deserializeOpAddProfileKey) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpAddProfileKey) 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_deserializeOpErrorAddProfileKey(response, &metadata) 44 } 45 output := &AddProfileKeyOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsRestjson1_deserializeOpDocumentAddProfileKeyOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 return out, metadata, &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 } 75 76 return out, metadata, err 77} 78 79func awsRestjson1_deserializeOpErrorAddProfileKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("AccessDeniedException", errorCode): 121 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 122 123 case strings.EqualFold("BadRequestException", errorCode): 124 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 125 126 case strings.EqualFold("InternalServerException", errorCode): 127 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 128 129 case strings.EqualFold("ResourceNotFoundException", errorCode): 130 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 131 132 case strings.EqualFold("ThrottlingException", errorCode): 133 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 134 135 default: 136 genericError := &smithy.GenericAPIError{ 137 Code: errorCode, 138 Message: errorMessage, 139 } 140 return genericError 141 142 } 143} 144 145func awsRestjson1_deserializeOpDocumentAddProfileKeyOutput(v **AddProfileKeyOutput, value interface{}) error { 146 if v == nil { 147 return fmt.Errorf("unexpected nil of type %T", v) 148 } 149 if value == nil { 150 return nil 151 } 152 153 shape, ok := value.(map[string]interface{}) 154 if !ok { 155 return fmt.Errorf("unexpected JSON type %v", value) 156 } 157 158 var sv *AddProfileKeyOutput 159 if *v == nil { 160 sv = &AddProfileKeyOutput{} 161 } else { 162 sv = *v 163 } 164 165 for key, value := range shape { 166 switch key { 167 case "KeyName": 168 if value != nil { 169 jtv, ok := value.(string) 170 if !ok { 171 return fmt.Errorf("expected name to be of type string, got %T instead", value) 172 } 173 sv.KeyName = ptr.String(jtv) 174 } 175 176 case "Values": 177 if err := awsRestjson1_deserializeDocumentRequestValueList(&sv.Values, value); err != nil { 178 return err 179 } 180 181 default: 182 _, _ = key, value 183 184 } 185 } 186 *v = sv 187 return nil 188} 189 190type awsRestjson1_deserializeOpCreateDomain struct { 191} 192 193func (*awsRestjson1_deserializeOpCreateDomain) ID() string { 194 return "OperationDeserializer" 195} 196 197func (m *awsRestjson1_deserializeOpCreateDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 198 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 199) { 200 out, metadata, err = next.HandleDeserialize(ctx, in) 201 if err != nil { 202 return out, metadata, err 203 } 204 205 response, ok := out.RawResponse.(*smithyhttp.Response) 206 if !ok { 207 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 208 } 209 210 if response.StatusCode < 200 || response.StatusCode >= 300 { 211 return out, metadata, awsRestjson1_deserializeOpErrorCreateDomain(response, &metadata) 212 } 213 output := &CreateDomainOutput{} 214 out.Result = output 215 216 var buff [1024]byte 217 ringBuffer := smithyio.NewRingBuffer(buff[:]) 218 219 body := io.TeeReader(response.Body, ringBuffer) 220 221 decoder := json.NewDecoder(body) 222 decoder.UseNumber() 223 var shape interface{} 224 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 225 var snapshot bytes.Buffer 226 io.Copy(&snapshot, ringBuffer) 227 err = &smithy.DeserializationError{ 228 Err: fmt.Errorf("failed to decode response body, %w", err), 229 Snapshot: snapshot.Bytes(), 230 } 231 return out, metadata, err 232 } 233 234 err = awsRestjson1_deserializeOpDocumentCreateDomainOutput(&output, shape) 235 if err != nil { 236 var snapshot bytes.Buffer 237 io.Copy(&snapshot, ringBuffer) 238 return out, metadata, &smithy.DeserializationError{ 239 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 240 Snapshot: snapshot.Bytes(), 241 } 242 } 243 244 return out, metadata, err 245} 246 247func awsRestjson1_deserializeOpErrorCreateDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 248 var errorBuffer bytes.Buffer 249 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 250 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 251 } 252 errorBody := bytes.NewReader(errorBuffer.Bytes()) 253 254 errorCode := "UnknownError" 255 errorMessage := errorCode 256 257 code := response.Header.Get("X-Amzn-ErrorType") 258 if len(code) != 0 { 259 errorCode = restjson.SanitizeErrorCode(code) 260 } 261 262 var buff [1024]byte 263 ringBuffer := smithyio.NewRingBuffer(buff[:]) 264 265 body := io.TeeReader(errorBody, ringBuffer) 266 decoder := json.NewDecoder(body) 267 decoder.UseNumber() 268 code, message, err := restjson.GetErrorInfo(decoder) 269 if err != nil { 270 var snapshot bytes.Buffer 271 io.Copy(&snapshot, ringBuffer) 272 err = &smithy.DeserializationError{ 273 Err: fmt.Errorf("failed to decode response body, %w", err), 274 Snapshot: snapshot.Bytes(), 275 } 276 return err 277 } 278 279 errorBody.Seek(0, io.SeekStart) 280 if len(code) != 0 { 281 errorCode = restjson.SanitizeErrorCode(code) 282 } 283 if len(message) != 0 { 284 errorMessage = message 285 } 286 287 switch { 288 case strings.EqualFold("AccessDeniedException", errorCode): 289 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 290 291 case strings.EqualFold("BadRequestException", errorCode): 292 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 293 294 case strings.EqualFold("InternalServerException", errorCode): 295 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 296 297 case strings.EqualFold("ResourceNotFoundException", errorCode): 298 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 299 300 case strings.EqualFold("ThrottlingException", errorCode): 301 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 302 303 default: 304 genericError := &smithy.GenericAPIError{ 305 Code: errorCode, 306 Message: errorMessage, 307 } 308 return genericError 309 310 } 311} 312 313func awsRestjson1_deserializeOpDocumentCreateDomainOutput(v **CreateDomainOutput, value interface{}) error { 314 if v == nil { 315 return fmt.Errorf("unexpected nil of type %T", v) 316 } 317 if value == nil { 318 return nil 319 } 320 321 shape, ok := value.(map[string]interface{}) 322 if !ok { 323 return fmt.Errorf("unexpected JSON type %v", value) 324 } 325 326 var sv *CreateDomainOutput 327 if *v == nil { 328 sv = &CreateDomainOutput{} 329 } else { 330 sv = *v 331 } 332 333 for key, value := range shape { 334 switch key { 335 case "CreatedAt": 336 if value != nil { 337 jtv, ok := value.(json.Number) 338 if !ok { 339 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 340 } 341 f64, err := jtv.Float64() 342 if err != nil { 343 return err 344 } 345 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 346 } 347 348 case "DeadLetterQueueUrl": 349 if value != nil { 350 jtv, ok := value.(string) 351 if !ok { 352 return fmt.Errorf("expected sqsQueueUrl to be of type string, got %T instead", value) 353 } 354 sv.DeadLetterQueueUrl = ptr.String(jtv) 355 } 356 357 case "DefaultEncryptionKey": 358 if value != nil { 359 jtv, ok := value.(string) 360 if !ok { 361 return fmt.Errorf("expected encryptionKey to be of type string, got %T instead", value) 362 } 363 sv.DefaultEncryptionKey = ptr.String(jtv) 364 } 365 366 case "DefaultExpirationDays": 367 if value != nil { 368 jtv, ok := value.(json.Number) 369 if !ok { 370 return fmt.Errorf("expected expirationDaysInteger to be json.Number, got %T instead", value) 371 } 372 i64, err := jtv.Int64() 373 if err != nil { 374 return err 375 } 376 sv.DefaultExpirationDays = ptr.Int32(int32(i64)) 377 } 378 379 case "DomainName": 380 if value != nil { 381 jtv, ok := value.(string) 382 if !ok { 383 return fmt.Errorf("expected name to be of type string, got %T instead", value) 384 } 385 sv.DomainName = ptr.String(jtv) 386 } 387 388 case "LastUpdatedAt": 389 if value != nil { 390 jtv, ok := value.(json.Number) 391 if !ok { 392 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 393 } 394 f64, err := jtv.Float64() 395 if err != nil { 396 return err 397 } 398 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 399 } 400 401 case "Tags": 402 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 403 return err 404 } 405 406 default: 407 _, _ = key, value 408 409 } 410 } 411 *v = sv 412 return nil 413} 414 415type awsRestjson1_deserializeOpCreateProfile struct { 416} 417 418func (*awsRestjson1_deserializeOpCreateProfile) ID() string { 419 return "OperationDeserializer" 420} 421 422func (m *awsRestjson1_deserializeOpCreateProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 423 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 424) { 425 out, metadata, err = next.HandleDeserialize(ctx, in) 426 if err != nil { 427 return out, metadata, err 428 } 429 430 response, ok := out.RawResponse.(*smithyhttp.Response) 431 if !ok { 432 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 433 } 434 435 if response.StatusCode < 200 || response.StatusCode >= 300 { 436 return out, metadata, awsRestjson1_deserializeOpErrorCreateProfile(response, &metadata) 437 } 438 output := &CreateProfileOutput{} 439 out.Result = output 440 441 var buff [1024]byte 442 ringBuffer := smithyio.NewRingBuffer(buff[:]) 443 444 body := io.TeeReader(response.Body, ringBuffer) 445 446 decoder := json.NewDecoder(body) 447 decoder.UseNumber() 448 var shape interface{} 449 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 450 var snapshot bytes.Buffer 451 io.Copy(&snapshot, ringBuffer) 452 err = &smithy.DeserializationError{ 453 Err: fmt.Errorf("failed to decode response body, %w", err), 454 Snapshot: snapshot.Bytes(), 455 } 456 return out, metadata, err 457 } 458 459 err = awsRestjson1_deserializeOpDocumentCreateProfileOutput(&output, shape) 460 if err != nil { 461 var snapshot bytes.Buffer 462 io.Copy(&snapshot, ringBuffer) 463 return out, metadata, &smithy.DeserializationError{ 464 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 465 Snapshot: snapshot.Bytes(), 466 } 467 } 468 469 return out, metadata, err 470} 471 472func awsRestjson1_deserializeOpErrorCreateProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error { 473 var errorBuffer bytes.Buffer 474 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 475 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 476 } 477 errorBody := bytes.NewReader(errorBuffer.Bytes()) 478 479 errorCode := "UnknownError" 480 errorMessage := errorCode 481 482 code := response.Header.Get("X-Amzn-ErrorType") 483 if len(code) != 0 { 484 errorCode = restjson.SanitizeErrorCode(code) 485 } 486 487 var buff [1024]byte 488 ringBuffer := smithyio.NewRingBuffer(buff[:]) 489 490 body := io.TeeReader(errorBody, ringBuffer) 491 decoder := json.NewDecoder(body) 492 decoder.UseNumber() 493 code, message, err := restjson.GetErrorInfo(decoder) 494 if err != nil { 495 var snapshot bytes.Buffer 496 io.Copy(&snapshot, ringBuffer) 497 err = &smithy.DeserializationError{ 498 Err: fmt.Errorf("failed to decode response body, %w", err), 499 Snapshot: snapshot.Bytes(), 500 } 501 return err 502 } 503 504 errorBody.Seek(0, io.SeekStart) 505 if len(code) != 0 { 506 errorCode = restjson.SanitizeErrorCode(code) 507 } 508 if len(message) != 0 { 509 errorMessage = message 510 } 511 512 switch { 513 case strings.EqualFold("AccessDeniedException", errorCode): 514 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 515 516 case strings.EqualFold("BadRequestException", errorCode): 517 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 518 519 case strings.EqualFold("InternalServerException", errorCode): 520 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 521 522 case strings.EqualFold("ResourceNotFoundException", errorCode): 523 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 524 525 case strings.EqualFold("ThrottlingException", errorCode): 526 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 527 528 default: 529 genericError := &smithy.GenericAPIError{ 530 Code: errorCode, 531 Message: errorMessage, 532 } 533 return genericError 534 535 } 536} 537 538func awsRestjson1_deserializeOpDocumentCreateProfileOutput(v **CreateProfileOutput, value interface{}) error { 539 if v == nil { 540 return fmt.Errorf("unexpected nil of type %T", v) 541 } 542 if value == nil { 543 return nil 544 } 545 546 shape, ok := value.(map[string]interface{}) 547 if !ok { 548 return fmt.Errorf("unexpected JSON type %v", value) 549 } 550 551 var sv *CreateProfileOutput 552 if *v == nil { 553 sv = &CreateProfileOutput{} 554 } else { 555 sv = *v 556 } 557 558 for key, value := range shape { 559 switch key { 560 case "ProfileId": 561 if value != nil { 562 jtv, ok := value.(string) 563 if !ok { 564 return fmt.Errorf("expected uuid to be of type string, got %T instead", value) 565 } 566 sv.ProfileId = ptr.String(jtv) 567 } 568 569 default: 570 _, _ = key, value 571 572 } 573 } 574 *v = sv 575 return nil 576} 577 578type awsRestjson1_deserializeOpDeleteDomain struct { 579} 580 581func (*awsRestjson1_deserializeOpDeleteDomain) ID() string { 582 return "OperationDeserializer" 583} 584 585func (m *awsRestjson1_deserializeOpDeleteDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 586 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 587) { 588 out, metadata, err = next.HandleDeserialize(ctx, in) 589 if err != nil { 590 return out, metadata, err 591 } 592 593 response, ok := out.RawResponse.(*smithyhttp.Response) 594 if !ok { 595 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 596 } 597 598 if response.StatusCode < 200 || response.StatusCode >= 300 { 599 return out, metadata, awsRestjson1_deserializeOpErrorDeleteDomain(response, &metadata) 600 } 601 output := &DeleteDomainOutput{} 602 out.Result = output 603 604 var buff [1024]byte 605 ringBuffer := smithyio.NewRingBuffer(buff[:]) 606 607 body := io.TeeReader(response.Body, ringBuffer) 608 609 decoder := json.NewDecoder(body) 610 decoder.UseNumber() 611 var shape interface{} 612 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 613 var snapshot bytes.Buffer 614 io.Copy(&snapshot, ringBuffer) 615 err = &smithy.DeserializationError{ 616 Err: fmt.Errorf("failed to decode response body, %w", err), 617 Snapshot: snapshot.Bytes(), 618 } 619 return out, metadata, err 620 } 621 622 err = awsRestjson1_deserializeOpDocumentDeleteDomainOutput(&output, shape) 623 if err != nil { 624 var snapshot bytes.Buffer 625 io.Copy(&snapshot, ringBuffer) 626 return out, metadata, &smithy.DeserializationError{ 627 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 628 Snapshot: snapshot.Bytes(), 629 } 630 } 631 632 return out, metadata, err 633} 634 635func awsRestjson1_deserializeOpErrorDeleteDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 636 var errorBuffer bytes.Buffer 637 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 638 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 639 } 640 errorBody := bytes.NewReader(errorBuffer.Bytes()) 641 642 errorCode := "UnknownError" 643 errorMessage := errorCode 644 645 code := response.Header.Get("X-Amzn-ErrorType") 646 if len(code) != 0 { 647 errorCode = restjson.SanitizeErrorCode(code) 648 } 649 650 var buff [1024]byte 651 ringBuffer := smithyio.NewRingBuffer(buff[:]) 652 653 body := io.TeeReader(errorBody, ringBuffer) 654 decoder := json.NewDecoder(body) 655 decoder.UseNumber() 656 code, message, err := restjson.GetErrorInfo(decoder) 657 if err != nil { 658 var snapshot bytes.Buffer 659 io.Copy(&snapshot, ringBuffer) 660 err = &smithy.DeserializationError{ 661 Err: fmt.Errorf("failed to decode response body, %w", err), 662 Snapshot: snapshot.Bytes(), 663 } 664 return err 665 } 666 667 errorBody.Seek(0, io.SeekStart) 668 if len(code) != 0 { 669 errorCode = restjson.SanitizeErrorCode(code) 670 } 671 if len(message) != 0 { 672 errorMessage = message 673 } 674 675 switch { 676 case strings.EqualFold("AccessDeniedException", errorCode): 677 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 678 679 case strings.EqualFold("BadRequestException", errorCode): 680 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 681 682 case strings.EqualFold("InternalServerException", errorCode): 683 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 684 685 case strings.EqualFold("ResourceNotFoundException", errorCode): 686 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 687 688 case strings.EqualFold("ThrottlingException", errorCode): 689 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 690 691 default: 692 genericError := &smithy.GenericAPIError{ 693 Code: errorCode, 694 Message: errorMessage, 695 } 696 return genericError 697 698 } 699} 700 701func awsRestjson1_deserializeOpDocumentDeleteDomainOutput(v **DeleteDomainOutput, value interface{}) error { 702 if v == nil { 703 return fmt.Errorf("unexpected nil of type %T", v) 704 } 705 if value == nil { 706 return nil 707 } 708 709 shape, ok := value.(map[string]interface{}) 710 if !ok { 711 return fmt.Errorf("unexpected JSON type %v", value) 712 } 713 714 var sv *DeleteDomainOutput 715 if *v == nil { 716 sv = &DeleteDomainOutput{} 717 } else { 718 sv = *v 719 } 720 721 for key, value := range shape { 722 switch key { 723 case "Message": 724 if value != nil { 725 jtv, ok := value.(string) 726 if !ok { 727 return fmt.Errorf("expected message to be of type string, got %T instead", value) 728 } 729 sv.Message = ptr.String(jtv) 730 } 731 732 default: 733 _, _ = key, value 734 735 } 736 } 737 *v = sv 738 return nil 739} 740 741type awsRestjson1_deserializeOpDeleteIntegration struct { 742} 743 744func (*awsRestjson1_deserializeOpDeleteIntegration) ID() string { 745 return "OperationDeserializer" 746} 747 748func (m *awsRestjson1_deserializeOpDeleteIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 749 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 750) { 751 out, metadata, err = next.HandleDeserialize(ctx, in) 752 if err != nil { 753 return out, metadata, err 754 } 755 756 response, ok := out.RawResponse.(*smithyhttp.Response) 757 if !ok { 758 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 759 } 760 761 if response.StatusCode < 200 || response.StatusCode >= 300 { 762 return out, metadata, awsRestjson1_deserializeOpErrorDeleteIntegration(response, &metadata) 763 } 764 output := &DeleteIntegrationOutput{} 765 out.Result = output 766 767 var buff [1024]byte 768 ringBuffer := smithyio.NewRingBuffer(buff[:]) 769 770 body := io.TeeReader(response.Body, ringBuffer) 771 772 decoder := json.NewDecoder(body) 773 decoder.UseNumber() 774 var shape interface{} 775 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 776 var snapshot bytes.Buffer 777 io.Copy(&snapshot, ringBuffer) 778 err = &smithy.DeserializationError{ 779 Err: fmt.Errorf("failed to decode response body, %w", err), 780 Snapshot: snapshot.Bytes(), 781 } 782 return out, metadata, err 783 } 784 785 err = awsRestjson1_deserializeOpDocumentDeleteIntegrationOutput(&output, shape) 786 if err != nil { 787 var snapshot bytes.Buffer 788 io.Copy(&snapshot, ringBuffer) 789 return out, metadata, &smithy.DeserializationError{ 790 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 791 Snapshot: snapshot.Bytes(), 792 } 793 } 794 795 return out, metadata, err 796} 797 798func awsRestjson1_deserializeOpErrorDeleteIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 799 var errorBuffer bytes.Buffer 800 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 801 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 802 } 803 errorBody := bytes.NewReader(errorBuffer.Bytes()) 804 805 errorCode := "UnknownError" 806 errorMessage := errorCode 807 808 code := response.Header.Get("X-Amzn-ErrorType") 809 if len(code) != 0 { 810 errorCode = restjson.SanitizeErrorCode(code) 811 } 812 813 var buff [1024]byte 814 ringBuffer := smithyio.NewRingBuffer(buff[:]) 815 816 body := io.TeeReader(errorBody, ringBuffer) 817 decoder := json.NewDecoder(body) 818 decoder.UseNumber() 819 code, message, err := restjson.GetErrorInfo(decoder) 820 if err != nil { 821 var snapshot bytes.Buffer 822 io.Copy(&snapshot, ringBuffer) 823 err = &smithy.DeserializationError{ 824 Err: fmt.Errorf("failed to decode response body, %w", err), 825 Snapshot: snapshot.Bytes(), 826 } 827 return err 828 } 829 830 errorBody.Seek(0, io.SeekStart) 831 if len(code) != 0 { 832 errorCode = restjson.SanitizeErrorCode(code) 833 } 834 if len(message) != 0 { 835 errorMessage = message 836 } 837 838 switch { 839 case strings.EqualFold("AccessDeniedException", errorCode): 840 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 841 842 case strings.EqualFold("BadRequestException", errorCode): 843 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 844 845 case strings.EqualFold("InternalServerException", errorCode): 846 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 847 848 case strings.EqualFold("ResourceNotFoundException", errorCode): 849 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 850 851 case strings.EqualFold("ThrottlingException", errorCode): 852 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 853 854 default: 855 genericError := &smithy.GenericAPIError{ 856 Code: errorCode, 857 Message: errorMessage, 858 } 859 return genericError 860 861 } 862} 863 864func awsRestjson1_deserializeOpDocumentDeleteIntegrationOutput(v **DeleteIntegrationOutput, value interface{}) error { 865 if v == nil { 866 return fmt.Errorf("unexpected nil of type %T", v) 867 } 868 if value == nil { 869 return nil 870 } 871 872 shape, ok := value.(map[string]interface{}) 873 if !ok { 874 return fmt.Errorf("unexpected JSON type %v", value) 875 } 876 877 var sv *DeleteIntegrationOutput 878 if *v == nil { 879 sv = &DeleteIntegrationOutput{} 880 } else { 881 sv = *v 882 } 883 884 for key, value := range shape { 885 switch key { 886 case "Message": 887 if value != nil { 888 jtv, ok := value.(string) 889 if !ok { 890 return fmt.Errorf("expected message to be of type string, got %T instead", value) 891 } 892 sv.Message = ptr.String(jtv) 893 } 894 895 default: 896 _, _ = key, value 897 898 } 899 } 900 *v = sv 901 return nil 902} 903 904type awsRestjson1_deserializeOpDeleteProfile struct { 905} 906 907func (*awsRestjson1_deserializeOpDeleteProfile) ID() string { 908 return "OperationDeserializer" 909} 910 911func (m *awsRestjson1_deserializeOpDeleteProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 912 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 913) { 914 out, metadata, err = next.HandleDeserialize(ctx, in) 915 if err != nil { 916 return out, metadata, err 917 } 918 919 response, ok := out.RawResponse.(*smithyhttp.Response) 920 if !ok { 921 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 922 } 923 924 if response.StatusCode < 200 || response.StatusCode >= 300 { 925 return out, metadata, awsRestjson1_deserializeOpErrorDeleteProfile(response, &metadata) 926 } 927 output := &DeleteProfileOutput{} 928 out.Result = output 929 930 var buff [1024]byte 931 ringBuffer := smithyio.NewRingBuffer(buff[:]) 932 933 body := io.TeeReader(response.Body, ringBuffer) 934 935 decoder := json.NewDecoder(body) 936 decoder.UseNumber() 937 var shape interface{} 938 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 939 var snapshot bytes.Buffer 940 io.Copy(&snapshot, ringBuffer) 941 err = &smithy.DeserializationError{ 942 Err: fmt.Errorf("failed to decode response body, %w", err), 943 Snapshot: snapshot.Bytes(), 944 } 945 return out, metadata, err 946 } 947 948 err = awsRestjson1_deserializeOpDocumentDeleteProfileOutput(&output, shape) 949 if err != nil { 950 var snapshot bytes.Buffer 951 io.Copy(&snapshot, ringBuffer) 952 return out, metadata, &smithy.DeserializationError{ 953 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 954 Snapshot: snapshot.Bytes(), 955 } 956 } 957 958 return out, metadata, err 959} 960 961func awsRestjson1_deserializeOpErrorDeleteProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error { 962 var errorBuffer bytes.Buffer 963 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 964 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 965 } 966 errorBody := bytes.NewReader(errorBuffer.Bytes()) 967 968 errorCode := "UnknownError" 969 errorMessage := errorCode 970 971 code := response.Header.Get("X-Amzn-ErrorType") 972 if len(code) != 0 { 973 errorCode = restjson.SanitizeErrorCode(code) 974 } 975 976 var buff [1024]byte 977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 978 979 body := io.TeeReader(errorBody, ringBuffer) 980 decoder := json.NewDecoder(body) 981 decoder.UseNumber() 982 code, message, err := restjson.GetErrorInfo(decoder) 983 if err != nil { 984 var snapshot bytes.Buffer 985 io.Copy(&snapshot, ringBuffer) 986 err = &smithy.DeserializationError{ 987 Err: fmt.Errorf("failed to decode response body, %w", err), 988 Snapshot: snapshot.Bytes(), 989 } 990 return err 991 } 992 993 errorBody.Seek(0, io.SeekStart) 994 if len(code) != 0 { 995 errorCode = restjson.SanitizeErrorCode(code) 996 } 997 if len(message) != 0 { 998 errorMessage = message 999 } 1000 1001 switch { 1002 case strings.EqualFold("AccessDeniedException", errorCode): 1003 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1004 1005 case strings.EqualFold("BadRequestException", errorCode): 1006 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1007 1008 case strings.EqualFold("InternalServerException", errorCode): 1009 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1010 1011 case strings.EqualFold("ResourceNotFoundException", errorCode): 1012 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1013 1014 case strings.EqualFold("ThrottlingException", errorCode): 1015 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1016 1017 default: 1018 genericError := &smithy.GenericAPIError{ 1019 Code: errorCode, 1020 Message: errorMessage, 1021 } 1022 return genericError 1023 1024 } 1025} 1026 1027func awsRestjson1_deserializeOpDocumentDeleteProfileOutput(v **DeleteProfileOutput, value interface{}) error { 1028 if v == nil { 1029 return fmt.Errorf("unexpected nil of type %T", v) 1030 } 1031 if value == nil { 1032 return nil 1033 } 1034 1035 shape, ok := value.(map[string]interface{}) 1036 if !ok { 1037 return fmt.Errorf("unexpected JSON type %v", value) 1038 } 1039 1040 var sv *DeleteProfileOutput 1041 if *v == nil { 1042 sv = &DeleteProfileOutput{} 1043 } else { 1044 sv = *v 1045 } 1046 1047 for key, value := range shape { 1048 switch key { 1049 case "Message": 1050 if value != nil { 1051 jtv, ok := value.(string) 1052 if !ok { 1053 return fmt.Errorf("expected message to be of type string, got %T instead", value) 1054 } 1055 sv.Message = ptr.String(jtv) 1056 } 1057 1058 default: 1059 _, _ = key, value 1060 1061 } 1062 } 1063 *v = sv 1064 return nil 1065} 1066 1067type awsRestjson1_deserializeOpDeleteProfileKey struct { 1068} 1069 1070func (*awsRestjson1_deserializeOpDeleteProfileKey) ID() string { 1071 return "OperationDeserializer" 1072} 1073 1074func (m *awsRestjson1_deserializeOpDeleteProfileKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1075 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1076) { 1077 out, metadata, err = next.HandleDeserialize(ctx, in) 1078 if err != nil { 1079 return out, metadata, err 1080 } 1081 1082 response, ok := out.RawResponse.(*smithyhttp.Response) 1083 if !ok { 1084 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1085 } 1086 1087 if response.StatusCode < 200 || response.StatusCode >= 300 { 1088 return out, metadata, awsRestjson1_deserializeOpErrorDeleteProfileKey(response, &metadata) 1089 } 1090 output := &DeleteProfileKeyOutput{} 1091 out.Result = output 1092 1093 var buff [1024]byte 1094 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1095 1096 body := io.TeeReader(response.Body, ringBuffer) 1097 1098 decoder := json.NewDecoder(body) 1099 decoder.UseNumber() 1100 var shape interface{} 1101 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1102 var snapshot bytes.Buffer 1103 io.Copy(&snapshot, ringBuffer) 1104 err = &smithy.DeserializationError{ 1105 Err: fmt.Errorf("failed to decode response body, %w", err), 1106 Snapshot: snapshot.Bytes(), 1107 } 1108 return out, metadata, err 1109 } 1110 1111 err = awsRestjson1_deserializeOpDocumentDeleteProfileKeyOutput(&output, shape) 1112 if err != nil { 1113 var snapshot bytes.Buffer 1114 io.Copy(&snapshot, ringBuffer) 1115 return out, metadata, &smithy.DeserializationError{ 1116 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1117 Snapshot: snapshot.Bytes(), 1118 } 1119 } 1120 1121 return out, metadata, err 1122} 1123 1124func awsRestjson1_deserializeOpErrorDeleteProfileKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1125 var errorBuffer bytes.Buffer 1126 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1127 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1128 } 1129 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1130 1131 errorCode := "UnknownError" 1132 errorMessage := errorCode 1133 1134 code := response.Header.Get("X-Amzn-ErrorType") 1135 if len(code) != 0 { 1136 errorCode = restjson.SanitizeErrorCode(code) 1137 } 1138 1139 var buff [1024]byte 1140 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1141 1142 body := io.TeeReader(errorBody, ringBuffer) 1143 decoder := json.NewDecoder(body) 1144 decoder.UseNumber() 1145 code, message, err := restjson.GetErrorInfo(decoder) 1146 if err != nil { 1147 var snapshot bytes.Buffer 1148 io.Copy(&snapshot, ringBuffer) 1149 err = &smithy.DeserializationError{ 1150 Err: fmt.Errorf("failed to decode response body, %w", err), 1151 Snapshot: snapshot.Bytes(), 1152 } 1153 return err 1154 } 1155 1156 errorBody.Seek(0, io.SeekStart) 1157 if len(code) != 0 { 1158 errorCode = restjson.SanitizeErrorCode(code) 1159 } 1160 if len(message) != 0 { 1161 errorMessage = message 1162 } 1163 1164 switch { 1165 case strings.EqualFold("AccessDeniedException", errorCode): 1166 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1167 1168 case strings.EqualFold("BadRequestException", errorCode): 1169 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1170 1171 case strings.EqualFold("InternalServerException", errorCode): 1172 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1173 1174 case strings.EqualFold("ResourceNotFoundException", errorCode): 1175 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1176 1177 case strings.EqualFold("ThrottlingException", errorCode): 1178 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1179 1180 default: 1181 genericError := &smithy.GenericAPIError{ 1182 Code: errorCode, 1183 Message: errorMessage, 1184 } 1185 return genericError 1186 1187 } 1188} 1189 1190func awsRestjson1_deserializeOpDocumentDeleteProfileKeyOutput(v **DeleteProfileKeyOutput, value interface{}) error { 1191 if v == nil { 1192 return fmt.Errorf("unexpected nil of type %T", v) 1193 } 1194 if value == nil { 1195 return nil 1196 } 1197 1198 shape, ok := value.(map[string]interface{}) 1199 if !ok { 1200 return fmt.Errorf("unexpected JSON type %v", value) 1201 } 1202 1203 var sv *DeleteProfileKeyOutput 1204 if *v == nil { 1205 sv = &DeleteProfileKeyOutput{} 1206 } else { 1207 sv = *v 1208 } 1209 1210 for key, value := range shape { 1211 switch key { 1212 case "Message": 1213 if value != nil { 1214 jtv, ok := value.(string) 1215 if !ok { 1216 return fmt.Errorf("expected message to be of type string, got %T instead", value) 1217 } 1218 sv.Message = ptr.String(jtv) 1219 } 1220 1221 default: 1222 _, _ = key, value 1223 1224 } 1225 } 1226 *v = sv 1227 return nil 1228} 1229 1230type awsRestjson1_deserializeOpDeleteProfileObject struct { 1231} 1232 1233func (*awsRestjson1_deserializeOpDeleteProfileObject) ID() string { 1234 return "OperationDeserializer" 1235} 1236 1237func (m *awsRestjson1_deserializeOpDeleteProfileObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1238 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1239) { 1240 out, metadata, err = next.HandleDeserialize(ctx, in) 1241 if err != nil { 1242 return out, metadata, err 1243 } 1244 1245 response, ok := out.RawResponse.(*smithyhttp.Response) 1246 if !ok { 1247 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1248 } 1249 1250 if response.StatusCode < 200 || response.StatusCode >= 300 { 1251 return out, metadata, awsRestjson1_deserializeOpErrorDeleteProfileObject(response, &metadata) 1252 } 1253 output := &DeleteProfileObjectOutput{} 1254 out.Result = output 1255 1256 var buff [1024]byte 1257 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1258 1259 body := io.TeeReader(response.Body, ringBuffer) 1260 1261 decoder := json.NewDecoder(body) 1262 decoder.UseNumber() 1263 var shape interface{} 1264 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1265 var snapshot bytes.Buffer 1266 io.Copy(&snapshot, ringBuffer) 1267 err = &smithy.DeserializationError{ 1268 Err: fmt.Errorf("failed to decode response body, %w", err), 1269 Snapshot: snapshot.Bytes(), 1270 } 1271 return out, metadata, err 1272 } 1273 1274 err = awsRestjson1_deserializeOpDocumentDeleteProfileObjectOutput(&output, shape) 1275 if err != nil { 1276 var snapshot bytes.Buffer 1277 io.Copy(&snapshot, ringBuffer) 1278 return out, metadata, &smithy.DeserializationError{ 1279 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1280 Snapshot: snapshot.Bytes(), 1281 } 1282 } 1283 1284 return out, metadata, err 1285} 1286 1287func awsRestjson1_deserializeOpErrorDeleteProfileObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1288 var errorBuffer bytes.Buffer 1289 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1290 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1291 } 1292 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1293 1294 errorCode := "UnknownError" 1295 errorMessage := errorCode 1296 1297 code := response.Header.Get("X-Amzn-ErrorType") 1298 if len(code) != 0 { 1299 errorCode = restjson.SanitizeErrorCode(code) 1300 } 1301 1302 var buff [1024]byte 1303 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1304 1305 body := io.TeeReader(errorBody, ringBuffer) 1306 decoder := json.NewDecoder(body) 1307 decoder.UseNumber() 1308 code, message, err := restjson.GetErrorInfo(decoder) 1309 if err != nil { 1310 var snapshot bytes.Buffer 1311 io.Copy(&snapshot, ringBuffer) 1312 err = &smithy.DeserializationError{ 1313 Err: fmt.Errorf("failed to decode response body, %w", err), 1314 Snapshot: snapshot.Bytes(), 1315 } 1316 return err 1317 } 1318 1319 errorBody.Seek(0, io.SeekStart) 1320 if len(code) != 0 { 1321 errorCode = restjson.SanitizeErrorCode(code) 1322 } 1323 if len(message) != 0 { 1324 errorMessage = message 1325 } 1326 1327 switch { 1328 case strings.EqualFold("AccessDeniedException", errorCode): 1329 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1330 1331 case strings.EqualFold("BadRequestException", errorCode): 1332 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1333 1334 case strings.EqualFold("InternalServerException", errorCode): 1335 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1336 1337 case strings.EqualFold("ResourceNotFoundException", errorCode): 1338 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1339 1340 case strings.EqualFold("ThrottlingException", errorCode): 1341 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1342 1343 default: 1344 genericError := &smithy.GenericAPIError{ 1345 Code: errorCode, 1346 Message: errorMessage, 1347 } 1348 return genericError 1349 1350 } 1351} 1352 1353func awsRestjson1_deserializeOpDocumentDeleteProfileObjectOutput(v **DeleteProfileObjectOutput, value interface{}) error { 1354 if v == nil { 1355 return fmt.Errorf("unexpected nil of type %T", v) 1356 } 1357 if value == nil { 1358 return nil 1359 } 1360 1361 shape, ok := value.(map[string]interface{}) 1362 if !ok { 1363 return fmt.Errorf("unexpected JSON type %v", value) 1364 } 1365 1366 var sv *DeleteProfileObjectOutput 1367 if *v == nil { 1368 sv = &DeleteProfileObjectOutput{} 1369 } else { 1370 sv = *v 1371 } 1372 1373 for key, value := range shape { 1374 switch key { 1375 case "Message": 1376 if value != nil { 1377 jtv, ok := value.(string) 1378 if !ok { 1379 return fmt.Errorf("expected message to be of type string, got %T instead", value) 1380 } 1381 sv.Message = ptr.String(jtv) 1382 } 1383 1384 default: 1385 _, _ = key, value 1386 1387 } 1388 } 1389 *v = sv 1390 return nil 1391} 1392 1393type awsRestjson1_deserializeOpDeleteProfileObjectType struct { 1394} 1395 1396func (*awsRestjson1_deserializeOpDeleteProfileObjectType) ID() string { 1397 return "OperationDeserializer" 1398} 1399 1400func (m *awsRestjson1_deserializeOpDeleteProfileObjectType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1401 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1402) { 1403 out, metadata, err = next.HandleDeserialize(ctx, in) 1404 if err != nil { 1405 return out, metadata, err 1406 } 1407 1408 response, ok := out.RawResponse.(*smithyhttp.Response) 1409 if !ok { 1410 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1411 } 1412 1413 if response.StatusCode < 200 || response.StatusCode >= 300 { 1414 return out, metadata, awsRestjson1_deserializeOpErrorDeleteProfileObjectType(response, &metadata) 1415 } 1416 output := &DeleteProfileObjectTypeOutput{} 1417 out.Result = output 1418 1419 var buff [1024]byte 1420 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1421 1422 body := io.TeeReader(response.Body, ringBuffer) 1423 1424 decoder := json.NewDecoder(body) 1425 decoder.UseNumber() 1426 var shape interface{} 1427 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1428 var snapshot bytes.Buffer 1429 io.Copy(&snapshot, ringBuffer) 1430 err = &smithy.DeserializationError{ 1431 Err: fmt.Errorf("failed to decode response body, %w", err), 1432 Snapshot: snapshot.Bytes(), 1433 } 1434 return out, metadata, err 1435 } 1436 1437 err = awsRestjson1_deserializeOpDocumentDeleteProfileObjectTypeOutput(&output, shape) 1438 if err != nil { 1439 var snapshot bytes.Buffer 1440 io.Copy(&snapshot, ringBuffer) 1441 return out, metadata, &smithy.DeserializationError{ 1442 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1443 Snapshot: snapshot.Bytes(), 1444 } 1445 } 1446 1447 return out, metadata, err 1448} 1449 1450func awsRestjson1_deserializeOpErrorDeleteProfileObjectType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1451 var errorBuffer bytes.Buffer 1452 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1453 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1454 } 1455 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1456 1457 errorCode := "UnknownError" 1458 errorMessage := errorCode 1459 1460 code := response.Header.Get("X-Amzn-ErrorType") 1461 if len(code) != 0 { 1462 errorCode = restjson.SanitizeErrorCode(code) 1463 } 1464 1465 var buff [1024]byte 1466 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1467 1468 body := io.TeeReader(errorBody, ringBuffer) 1469 decoder := json.NewDecoder(body) 1470 decoder.UseNumber() 1471 code, message, err := restjson.GetErrorInfo(decoder) 1472 if err != nil { 1473 var snapshot bytes.Buffer 1474 io.Copy(&snapshot, ringBuffer) 1475 err = &smithy.DeserializationError{ 1476 Err: fmt.Errorf("failed to decode response body, %w", err), 1477 Snapshot: snapshot.Bytes(), 1478 } 1479 return err 1480 } 1481 1482 errorBody.Seek(0, io.SeekStart) 1483 if len(code) != 0 { 1484 errorCode = restjson.SanitizeErrorCode(code) 1485 } 1486 if len(message) != 0 { 1487 errorMessage = message 1488 } 1489 1490 switch { 1491 case strings.EqualFold("AccessDeniedException", errorCode): 1492 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1493 1494 case strings.EqualFold("BadRequestException", errorCode): 1495 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1496 1497 case strings.EqualFold("InternalServerException", errorCode): 1498 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1499 1500 case strings.EqualFold("ResourceNotFoundException", errorCode): 1501 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1502 1503 case strings.EqualFold("ThrottlingException", errorCode): 1504 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1505 1506 default: 1507 genericError := &smithy.GenericAPIError{ 1508 Code: errorCode, 1509 Message: errorMessage, 1510 } 1511 return genericError 1512 1513 } 1514} 1515 1516func awsRestjson1_deserializeOpDocumentDeleteProfileObjectTypeOutput(v **DeleteProfileObjectTypeOutput, value interface{}) error { 1517 if v == nil { 1518 return fmt.Errorf("unexpected nil of type %T", v) 1519 } 1520 if value == nil { 1521 return nil 1522 } 1523 1524 shape, ok := value.(map[string]interface{}) 1525 if !ok { 1526 return fmt.Errorf("unexpected JSON type %v", value) 1527 } 1528 1529 var sv *DeleteProfileObjectTypeOutput 1530 if *v == nil { 1531 sv = &DeleteProfileObjectTypeOutput{} 1532 } else { 1533 sv = *v 1534 } 1535 1536 for key, value := range shape { 1537 switch key { 1538 case "Message": 1539 if value != nil { 1540 jtv, ok := value.(string) 1541 if !ok { 1542 return fmt.Errorf("expected message to be of type string, got %T instead", value) 1543 } 1544 sv.Message = ptr.String(jtv) 1545 } 1546 1547 default: 1548 _, _ = key, value 1549 1550 } 1551 } 1552 *v = sv 1553 return nil 1554} 1555 1556type awsRestjson1_deserializeOpGetDomain struct { 1557} 1558 1559func (*awsRestjson1_deserializeOpGetDomain) ID() string { 1560 return "OperationDeserializer" 1561} 1562 1563func (m *awsRestjson1_deserializeOpGetDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1564 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1565) { 1566 out, metadata, err = next.HandleDeserialize(ctx, in) 1567 if err != nil { 1568 return out, metadata, err 1569 } 1570 1571 response, ok := out.RawResponse.(*smithyhttp.Response) 1572 if !ok { 1573 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1574 } 1575 1576 if response.StatusCode < 200 || response.StatusCode >= 300 { 1577 return out, metadata, awsRestjson1_deserializeOpErrorGetDomain(response, &metadata) 1578 } 1579 output := &GetDomainOutput{} 1580 out.Result = output 1581 1582 var buff [1024]byte 1583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1584 1585 body := io.TeeReader(response.Body, ringBuffer) 1586 1587 decoder := json.NewDecoder(body) 1588 decoder.UseNumber() 1589 var shape interface{} 1590 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1591 var snapshot bytes.Buffer 1592 io.Copy(&snapshot, ringBuffer) 1593 err = &smithy.DeserializationError{ 1594 Err: fmt.Errorf("failed to decode response body, %w", err), 1595 Snapshot: snapshot.Bytes(), 1596 } 1597 return out, metadata, err 1598 } 1599 1600 err = awsRestjson1_deserializeOpDocumentGetDomainOutput(&output, shape) 1601 if err != nil { 1602 var snapshot bytes.Buffer 1603 io.Copy(&snapshot, ringBuffer) 1604 return out, metadata, &smithy.DeserializationError{ 1605 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1606 Snapshot: snapshot.Bytes(), 1607 } 1608 } 1609 1610 return out, metadata, err 1611} 1612 1613func awsRestjson1_deserializeOpErrorGetDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1614 var errorBuffer bytes.Buffer 1615 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1616 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1617 } 1618 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1619 1620 errorCode := "UnknownError" 1621 errorMessage := errorCode 1622 1623 code := response.Header.Get("X-Amzn-ErrorType") 1624 if len(code) != 0 { 1625 errorCode = restjson.SanitizeErrorCode(code) 1626 } 1627 1628 var buff [1024]byte 1629 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1630 1631 body := io.TeeReader(errorBody, ringBuffer) 1632 decoder := json.NewDecoder(body) 1633 decoder.UseNumber() 1634 code, message, err := restjson.GetErrorInfo(decoder) 1635 if err != nil { 1636 var snapshot bytes.Buffer 1637 io.Copy(&snapshot, ringBuffer) 1638 err = &smithy.DeserializationError{ 1639 Err: fmt.Errorf("failed to decode response body, %w", err), 1640 Snapshot: snapshot.Bytes(), 1641 } 1642 return err 1643 } 1644 1645 errorBody.Seek(0, io.SeekStart) 1646 if len(code) != 0 { 1647 errorCode = restjson.SanitizeErrorCode(code) 1648 } 1649 if len(message) != 0 { 1650 errorMessage = message 1651 } 1652 1653 switch { 1654 case strings.EqualFold("AccessDeniedException", errorCode): 1655 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1656 1657 case strings.EqualFold("BadRequestException", errorCode): 1658 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1659 1660 case strings.EqualFold("InternalServerException", errorCode): 1661 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1662 1663 case strings.EqualFold("ResourceNotFoundException", errorCode): 1664 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1665 1666 case strings.EqualFold("ThrottlingException", errorCode): 1667 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1668 1669 default: 1670 genericError := &smithy.GenericAPIError{ 1671 Code: errorCode, 1672 Message: errorMessage, 1673 } 1674 return genericError 1675 1676 } 1677} 1678 1679func awsRestjson1_deserializeOpDocumentGetDomainOutput(v **GetDomainOutput, value interface{}) error { 1680 if v == nil { 1681 return fmt.Errorf("unexpected nil of type %T", v) 1682 } 1683 if value == nil { 1684 return nil 1685 } 1686 1687 shape, ok := value.(map[string]interface{}) 1688 if !ok { 1689 return fmt.Errorf("unexpected JSON type %v", value) 1690 } 1691 1692 var sv *GetDomainOutput 1693 if *v == nil { 1694 sv = &GetDomainOutput{} 1695 } else { 1696 sv = *v 1697 } 1698 1699 for key, value := range shape { 1700 switch key { 1701 case "CreatedAt": 1702 if value != nil { 1703 jtv, ok := value.(json.Number) 1704 if !ok { 1705 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 1706 } 1707 f64, err := jtv.Float64() 1708 if err != nil { 1709 return err 1710 } 1711 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1712 } 1713 1714 case "DeadLetterQueueUrl": 1715 if value != nil { 1716 jtv, ok := value.(string) 1717 if !ok { 1718 return fmt.Errorf("expected sqsQueueUrl to be of type string, got %T instead", value) 1719 } 1720 sv.DeadLetterQueueUrl = ptr.String(jtv) 1721 } 1722 1723 case "DefaultEncryptionKey": 1724 if value != nil { 1725 jtv, ok := value.(string) 1726 if !ok { 1727 return fmt.Errorf("expected encryptionKey to be of type string, got %T instead", value) 1728 } 1729 sv.DefaultEncryptionKey = ptr.String(jtv) 1730 } 1731 1732 case "DefaultExpirationDays": 1733 if value != nil { 1734 jtv, ok := value.(json.Number) 1735 if !ok { 1736 return fmt.Errorf("expected expirationDaysInteger to be json.Number, got %T instead", value) 1737 } 1738 i64, err := jtv.Int64() 1739 if err != nil { 1740 return err 1741 } 1742 sv.DefaultExpirationDays = ptr.Int32(int32(i64)) 1743 } 1744 1745 case "DomainName": 1746 if value != nil { 1747 jtv, ok := value.(string) 1748 if !ok { 1749 return fmt.Errorf("expected name to be of type string, got %T instead", value) 1750 } 1751 sv.DomainName = ptr.String(jtv) 1752 } 1753 1754 case "LastUpdatedAt": 1755 if value != nil { 1756 jtv, ok := value.(json.Number) 1757 if !ok { 1758 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 1759 } 1760 f64, err := jtv.Float64() 1761 if err != nil { 1762 return err 1763 } 1764 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1765 } 1766 1767 case "Stats": 1768 if err := awsRestjson1_deserializeDocumentDomainStats(&sv.Stats, value); err != nil { 1769 return err 1770 } 1771 1772 case "Tags": 1773 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 1774 return err 1775 } 1776 1777 default: 1778 _, _ = key, value 1779 1780 } 1781 } 1782 *v = sv 1783 return nil 1784} 1785 1786type awsRestjson1_deserializeOpGetIntegration struct { 1787} 1788 1789func (*awsRestjson1_deserializeOpGetIntegration) ID() string { 1790 return "OperationDeserializer" 1791} 1792 1793func (m *awsRestjson1_deserializeOpGetIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1794 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1795) { 1796 out, metadata, err = next.HandleDeserialize(ctx, in) 1797 if err != nil { 1798 return out, metadata, err 1799 } 1800 1801 response, ok := out.RawResponse.(*smithyhttp.Response) 1802 if !ok { 1803 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1804 } 1805 1806 if response.StatusCode < 200 || response.StatusCode >= 300 { 1807 return out, metadata, awsRestjson1_deserializeOpErrorGetIntegration(response, &metadata) 1808 } 1809 output := &GetIntegrationOutput{} 1810 out.Result = output 1811 1812 var buff [1024]byte 1813 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1814 1815 body := io.TeeReader(response.Body, ringBuffer) 1816 1817 decoder := json.NewDecoder(body) 1818 decoder.UseNumber() 1819 var shape interface{} 1820 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1821 var snapshot bytes.Buffer 1822 io.Copy(&snapshot, ringBuffer) 1823 err = &smithy.DeserializationError{ 1824 Err: fmt.Errorf("failed to decode response body, %w", err), 1825 Snapshot: snapshot.Bytes(), 1826 } 1827 return out, metadata, err 1828 } 1829 1830 err = awsRestjson1_deserializeOpDocumentGetIntegrationOutput(&output, shape) 1831 if err != nil { 1832 var snapshot bytes.Buffer 1833 io.Copy(&snapshot, ringBuffer) 1834 return out, metadata, &smithy.DeserializationError{ 1835 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1836 Snapshot: snapshot.Bytes(), 1837 } 1838 } 1839 1840 return out, metadata, err 1841} 1842 1843func awsRestjson1_deserializeOpErrorGetIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1844 var errorBuffer bytes.Buffer 1845 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1846 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1847 } 1848 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1849 1850 errorCode := "UnknownError" 1851 errorMessage := errorCode 1852 1853 code := response.Header.Get("X-Amzn-ErrorType") 1854 if len(code) != 0 { 1855 errorCode = restjson.SanitizeErrorCode(code) 1856 } 1857 1858 var buff [1024]byte 1859 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1860 1861 body := io.TeeReader(errorBody, ringBuffer) 1862 decoder := json.NewDecoder(body) 1863 decoder.UseNumber() 1864 code, message, err := restjson.GetErrorInfo(decoder) 1865 if err != nil { 1866 var snapshot bytes.Buffer 1867 io.Copy(&snapshot, ringBuffer) 1868 err = &smithy.DeserializationError{ 1869 Err: fmt.Errorf("failed to decode response body, %w", err), 1870 Snapshot: snapshot.Bytes(), 1871 } 1872 return err 1873 } 1874 1875 errorBody.Seek(0, io.SeekStart) 1876 if len(code) != 0 { 1877 errorCode = restjson.SanitizeErrorCode(code) 1878 } 1879 if len(message) != 0 { 1880 errorMessage = message 1881 } 1882 1883 switch { 1884 case strings.EqualFold("AccessDeniedException", errorCode): 1885 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1886 1887 case strings.EqualFold("BadRequestException", errorCode): 1888 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1889 1890 case strings.EqualFold("InternalServerException", errorCode): 1891 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1892 1893 case strings.EqualFold("ResourceNotFoundException", errorCode): 1894 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1895 1896 case strings.EqualFold("ThrottlingException", errorCode): 1897 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 1898 1899 default: 1900 genericError := &smithy.GenericAPIError{ 1901 Code: errorCode, 1902 Message: errorMessage, 1903 } 1904 return genericError 1905 1906 } 1907} 1908 1909func awsRestjson1_deserializeOpDocumentGetIntegrationOutput(v **GetIntegrationOutput, value interface{}) error { 1910 if v == nil { 1911 return fmt.Errorf("unexpected nil of type %T", v) 1912 } 1913 if value == nil { 1914 return nil 1915 } 1916 1917 shape, ok := value.(map[string]interface{}) 1918 if !ok { 1919 return fmt.Errorf("unexpected JSON type %v", value) 1920 } 1921 1922 var sv *GetIntegrationOutput 1923 if *v == nil { 1924 sv = &GetIntegrationOutput{} 1925 } else { 1926 sv = *v 1927 } 1928 1929 for key, value := range shape { 1930 switch key { 1931 case "CreatedAt": 1932 if value != nil { 1933 jtv, ok := value.(json.Number) 1934 if !ok { 1935 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 1936 } 1937 f64, err := jtv.Float64() 1938 if err != nil { 1939 return err 1940 } 1941 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1942 } 1943 1944 case "DomainName": 1945 if value != nil { 1946 jtv, ok := value.(string) 1947 if !ok { 1948 return fmt.Errorf("expected name to be of type string, got %T instead", value) 1949 } 1950 sv.DomainName = ptr.String(jtv) 1951 } 1952 1953 case "LastUpdatedAt": 1954 if value != nil { 1955 jtv, ok := value.(json.Number) 1956 if !ok { 1957 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 1958 } 1959 f64, err := jtv.Float64() 1960 if err != nil { 1961 return err 1962 } 1963 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1964 } 1965 1966 case "ObjectTypeName": 1967 if value != nil { 1968 jtv, ok := value.(string) 1969 if !ok { 1970 return fmt.Errorf("expected typeName to be of type string, got %T instead", value) 1971 } 1972 sv.ObjectTypeName = ptr.String(jtv) 1973 } 1974 1975 case "Tags": 1976 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 1977 return err 1978 } 1979 1980 case "Uri": 1981 if value != nil { 1982 jtv, ok := value.(string) 1983 if !ok { 1984 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 1985 } 1986 sv.Uri = ptr.String(jtv) 1987 } 1988 1989 default: 1990 _, _ = key, value 1991 1992 } 1993 } 1994 *v = sv 1995 return nil 1996} 1997 1998type awsRestjson1_deserializeOpGetProfileObjectType struct { 1999} 2000 2001func (*awsRestjson1_deserializeOpGetProfileObjectType) ID() string { 2002 return "OperationDeserializer" 2003} 2004 2005func (m *awsRestjson1_deserializeOpGetProfileObjectType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2006 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2007) { 2008 out, metadata, err = next.HandleDeserialize(ctx, in) 2009 if err != nil { 2010 return out, metadata, err 2011 } 2012 2013 response, ok := out.RawResponse.(*smithyhttp.Response) 2014 if !ok { 2015 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2016 } 2017 2018 if response.StatusCode < 200 || response.StatusCode >= 300 { 2019 return out, metadata, awsRestjson1_deserializeOpErrorGetProfileObjectType(response, &metadata) 2020 } 2021 output := &GetProfileObjectTypeOutput{} 2022 out.Result = output 2023 2024 var buff [1024]byte 2025 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2026 2027 body := io.TeeReader(response.Body, ringBuffer) 2028 2029 decoder := json.NewDecoder(body) 2030 decoder.UseNumber() 2031 var shape interface{} 2032 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2033 var snapshot bytes.Buffer 2034 io.Copy(&snapshot, ringBuffer) 2035 err = &smithy.DeserializationError{ 2036 Err: fmt.Errorf("failed to decode response body, %w", err), 2037 Snapshot: snapshot.Bytes(), 2038 } 2039 return out, metadata, err 2040 } 2041 2042 err = awsRestjson1_deserializeOpDocumentGetProfileObjectTypeOutput(&output, shape) 2043 if err != nil { 2044 var snapshot bytes.Buffer 2045 io.Copy(&snapshot, ringBuffer) 2046 return out, metadata, &smithy.DeserializationError{ 2047 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2048 Snapshot: snapshot.Bytes(), 2049 } 2050 } 2051 2052 return out, metadata, err 2053} 2054 2055func awsRestjson1_deserializeOpErrorGetProfileObjectType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2056 var errorBuffer bytes.Buffer 2057 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2058 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2059 } 2060 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2061 2062 errorCode := "UnknownError" 2063 errorMessage := errorCode 2064 2065 code := response.Header.Get("X-Amzn-ErrorType") 2066 if len(code) != 0 { 2067 errorCode = restjson.SanitizeErrorCode(code) 2068 } 2069 2070 var buff [1024]byte 2071 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2072 2073 body := io.TeeReader(errorBody, ringBuffer) 2074 decoder := json.NewDecoder(body) 2075 decoder.UseNumber() 2076 code, message, err := restjson.GetErrorInfo(decoder) 2077 if err != nil { 2078 var snapshot bytes.Buffer 2079 io.Copy(&snapshot, ringBuffer) 2080 err = &smithy.DeserializationError{ 2081 Err: fmt.Errorf("failed to decode response body, %w", err), 2082 Snapshot: snapshot.Bytes(), 2083 } 2084 return err 2085 } 2086 2087 errorBody.Seek(0, io.SeekStart) 2088 if len(code) != 0 { 2089 errorCode = restjson.SanitizeErrorCode(code) 2090 } 2091 if len(message) != 0 { 2092 errorMessage = message 2093 } 2094 2095 switch { 2096 case strings.EqualFold("AccessDeniedException", errorCode): 2097 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2098 2099 case strings.EqualFold("BadRequestException", errorCode): 2100 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2101 2102 case strings.EqualFold("InternalServerException", errorCode): 2103 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2104 2105 case strings.EqualFold("ResourceNotFoundException", errorCode): 2106 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2107 2108 case strings.EqualFold("ThrottlingException", errorCode): 2109 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2110 2111 default: 2112 genericError := &smithy.GenericAPIError{ 2113 Code: errorCode, 2114 Message: errorMessage, 2115 } 2116 return genericError 2117 2118 } 2119} 2120 2121func awsRestjson1_deserializeOpDocumentGetProfileObjectTypeOutput(v **GetProfileObjectTypeOutput, value interface{}) error { 2122 if v == nil { 2123 return fmt.Errorf("unexpected nil of type %T", v) 2124 } 2125 if value == nil { 2126 return nil 2127 } 2128 2129 shape, ok := value.(map[string]interface{}) 2130 if !ok { 2131 return fmt.Errorf("unexpected JSON type %v", value) 2132 } 2133 2134 var sv *GetProfileObjectTypeOutput 2135 if *v == nil { 2136 sv = &GetProfileObjectTypeOutput{} 2137 } else { 2138 sv = *v 2139 } 2140 2141 for key, value := range shape { 2142 switch key { 2143 case "AllowProfileCreation": 2144 if value != nil { 2145 jtv, ok := value.(bool) 2146 if !ok { 2147 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value) 2148 } 2149 sv.AllowProfileCreation = jtv 2150 } 2151 2152 case "CreatedAt": 2153 if value != nil { 2154 jtv, ok := value.(json.Number) 2155 if !ok { 2156 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2157 } 2158 f64, err := jtv.Float64() 2159 if err != nil { 2160 return err 2161 } 2162 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2163 } 2164 2165 case "Description": 2166 if value != nil { 2167 jtv, ok := value.(string) 2168 if !ok { 2169 return fmt.Errorf("expected text to be of type string, got %T instead", value) 2170 } 2171 sv.Description = ptr.String(jtv) 2172 } 2173 2174 case "EncryptionKey": 2175 if value != nil { 2176 jtv, ok := value.(string) 2177 if !ok { 2178 return fmt.Errorf("expected encryptionKey to be of type string, got %T instead", value) 2179 } 2180 sv.EncryptionKey = ptr.String(jtv) 2181 } 2182 2183 case "ExpirationDays": 2184 if value != nil { 2185 jtv, ok := value.(json.Number) 2186 if !ok { 2187 return fmt.Errorf("expected expirationDaysInteger to be json.Number, got %T instead", value) 2188 } 2189 i64, err := jtv.Int64() 2190 if err != nil { 2191 return err 2192 } 2193 sv.ExpirationDays = ptr.Int32(int32(i64)) 2194 } 2195 2196 case "Fields": 2197 if err := awsRestjson1_deserializeDocumentFieldMap(&sv.Fields, value); err != nil { 2198 return err 2199 } 2200 2201 case "Keys": 2202 if err := awsRestjson1_deserializeDocumentKeyMap(&sv.Keys, value); err != nil { 2203 return err 2204 } 2205 2206 case "LastUpdatedAt": 2207 if value != nil { 2208 jtv, ok := value.(json.Number) 2209 if !ok { 2210 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2211 } 2212 f64, err := jtv.Float64() 2213 if err != nil { 2214 return err 2215 } 2216 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2217 } 2218 2219 case "ObjectTypeName": 2220 if value != nil { 2221 jtv, ok := value.(string) 2222 if !ok { 2223 return fmt.Errorf("expected typeName to be of type string, got %T instead", value) 2224 } 2225 sv.ObjectTypeName = ptr.String(jtv) 2226 } 2227 2228 case "Tags": 2229 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 2230 return err 2231 } 2232 2233 case "TemplateId": 2234 if value != nil { 2235 jtv, ok := value.(string) 2236 if !ok { 2237 return fmt.Errorf("expected name to be of type string, got %T instead", value) 2238 } 2239 sv.TemplateId = ptr.String(jtv) 2240 } 2241 2242 default: 2243 _, _ = key, value 2244 2245 } 2246 } 2247 *v = sv 2248 return nil 2249} 2250 2251type awsRestjson1_deserializeOpGetProfileObjectTypeTemplate struct { 2252} 2253 2254func (*awsRestjson1_deserializeOpGetProfileObjectTypeTemplate) ID() string { 2255 return "OperationDeserializer" 2256} 2257 2258func (m *awsRestjson1_deserializeOpGetProfileObjectTypeTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2259 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2260) { 2261 out, metadata, err = next.HandleDeserialize(ctx, in) 2262 if err != nil { 2263 return out, metadata, err 2264 } 2265 2266 response, ok := out.RawResponse.(*smithyhttp.Response) 2267 if !ok { 2268 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2269 } 2270 2271 if response.StatusCode < 200 || response.StatusCode >= 300 { 2272 return out, metadata, awsRestjson1_deserializeOpErrorGetProfileObjectTypeTemplate(response, &metadata) 2273 } 2274 output := &GetProfileObjectTypeTemplateOutput{} 2275 out.Result = output 2276 2277 var buff [1024]byte 2278 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2279 2280 body := io.TeeReader(response.Body, ringBuffer) 2281 2282 decoder := json.NewDecoder(body) 2283 decoder.UseNumber() 2284 var shape interface{} 2285 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2286 var snapshot bytes.Buffer 2287 io.Copy(&snapshot, ringBuffer) 2288 err = &smithy.DeserializationError{ 2289 Err: fmt.Errorf("failed to decode response body, %w", err), 2290 Snapshot: snapshot.Bytes(), 2291 } 2292 return out, metadata, err 2293 } 2294 2295 err = awsRestjson1_deserializeOpDocumentGetProfileObjectTypeTemplateOutput(&output, shape) 2296 if err != nil { 2297 var snapshot bytes.Buffer 2298 io.Copy(&snapshot, ringBuffer) 2299 return out, metadata, &smithy.DeserializationError{ 2300 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2301 Snapshot: snapshot.Bytes(), 2302 } 2303 } 2304 2305 return out, metadata, err 2306} 2307 2308func awsRestjson1_deserializeOpErrorGetProfileObjectTypeTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2309 var errorBuffer bytes.Buffer 2310 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2311 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2312 } 2313 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2314 2315 errorCode := "UnknownError" 2316 errorMessage := errorCode 2317 2318 code := response.Header.Get("X-Amzn-ErrorType") 2319 if len(code) != 0 { 2320 errorCode = restjson.SanitizeErrorCode(code) 2321 } 2322 2323 var buff [1024]byte 2324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2325 2326 body := io.TeeReader(errorBody, ringBuffer) 2327 decoder := json.NewDecoder(body) 2328 decoder.UseNumber() 2329 code, message, err := restjson.GetErrorInfo(decoder) 2330 if err != nil { 2331 var snapshot bytes.Buffer 2332 io.Copy(&snapshot, ringBuffer) 2333 err = &smithy.DeserializationError{ 2334 Err: fmt.Errorf("failed to decode response body, %w", err), 2335 Snapshot: snapshot.Bytes(), 2336 } 2337 return err 2338 } 2339 2340 errorBody.Seek(0, io.SeekStart) 2341 if len(code) != 0 { 2342 errorCode = restjson.SanitizeErrorCode(code) 2343 } 2344 if len(message) != 0 { 2345 errorMessage = message 2346 } 2347 2348 switch { 2349 case strings.EqualFold("AccessDeniedException", errorCode): 2350 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2351 2352 case strings.EqualFold("BadRequestException", errorCode): 2353 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2354 2355 case strings.EqualFold("InternalServerException", errorCode): 2356 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2357 2358 case strings.EqualFold("ResourceNotFoundException", errorCode): 2359 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2360 2361 case strings.EqualFold("ThrottlingException", errorCode): 2362 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2363 2364 default: 2365 genericError := &smithy.GenericAPIError{ 2366 Code: errorCode, 2367 Message: errorMessage, 2368 } 2369 return genericError 2370 2371 } 2372} 2373 2374func awsRestjson1_deserializeOpDocumentGetProfileObjectTypeTemplateOutput(v **GetProfileObjectTypeTemplateOutput, value interface{}) error { 2375 if v == nil { 2376 return fmt.Errorf("unexpected nil of type %T", v) 2377 } 2378 if value == nil { 2379 return nil 2380 } 2381 2382 shape, ok := value.(map[string]interface{}) 2383 if !ok { 2384 return fmt.Errorf("unexpected JSON type %v", value) 2385 } 2386 2387 var sv *GetProfileObjectTypeTemplateOutput 2388 if *v == nil { 2389 sv = &GetProfileObjectTypeTemplateOutput{} 2390 } else { 2391 sv = *v 2392 } 2393 2394 for key, value := range shape { 2395 switch key { 2396 case "AllowProfileCreation": 2397 if value != nil { 2398 jtv, ok := value.(bool) 2399 if !ok { 2400 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value) 2401 } 2402 sv.AllowProfileCreation = jtv 2403 } 2404 2405 case "Fields": 2406 if err := awsRestjson1_deserializeDocumentFieldMap(&sv.Fields, value); err != nil { 2407 return err 2408 } 2409 2410 case "Keys": 2411 if err := awsRestjson1_deserializeDocumentKeyMap(&sv.Keys, value); err != nil { 2412 return err 2413 } 2414 2415 case "SourceName": 2416 if value != nil { 2417 jtv, ok := value.(string) 2418 if !ok { 2419 return fmt.Errorf("expected name to be of type string, got %T instead", value) 2420 } 2421 sv.SourceName = ptr.String(jtv) 2422 } 2423 2424 case "SourceObject": 2425 if value != nil { 2426 jtv, ok := value.(string) 2427 if !ok { 2428 return fmt.Errorf("expected name to be of type string, got %T instead", value) 2429 } 2430 sv.SourceObject = ptr.String(jtv) 2431 } 2432 2433 case "TemplateId": 2434 if value != nil { 2435 jtv, ok := value.(string) 2436 if !ok { 2437 return fmt.Errorf("expected name to be of type string, got %T instead", value) 2438 } 2439 sv.TemplateId = ptr.String(jtv) 2440 } 2441 2442 default: 2443 _, _ = key, value 2444 2445 } 2446 } 2447 *v = sv 2448 return nil 2449} 2450 2451type awsRestjson1_deserializeOpListAccountIntegrations struct { 2452} 2453 2454func (*awsRestjson1_deserializeOpListAccountIntegrations) ID() string { 2455 return "OperationDeserializer" 2456} 2457 2458func (m *awsRestjson1_deserializeOpListAccountIntegrations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2459 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2460) { 2461 out, metadata, err = next.HandleDeserialize(ctx, in) 2462 if err != nil { 2463 return out, metadata, err 2464 } 2465 2466 response, ok := out.RawResponse.(*smithyhttp.Response) 2467 if !ok { 2468 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2469 } 2470 2471 if response.StatusCode < 200 || response.StatusCode >= 300 { 2472 return out, metadata, awsRestjson1_deserializeOpErrorListAccountIntegrations(response, &metadata) 2473 } 2474 output := &ListAccountIntegrationsOutput{} 2475 out.Result = output 2476 2477 var buff [1024]byte 2478 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2479 2480 body := io.TeeReader(response.Body, ringBuffer) 2481 2482 decoder := json.NewDecoder(body) 2483 decoder.UseNumber() 2484 var shape interface{} 2485 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2486 var snapshot bytes.Buffer 2487 io.Copy(&snapshot, ringBuffer) 2488 err = &smithy.DeserializationError{ 2489 Err: fmt.Errorf("failed to decode response body, %w", err), 2490 Snapshot: snapshot.Bytes(), 2491 } 2492 return out, metadata, err 2493 } 2494 2495 err = awsRestjson1_deserializeOpDocumentListAccountIntegrationsOutput(&output, shape) 2496 if err != nil { 2497 var snapshot bytes.Buffer 2498 io.Copy(&snapshot, ringBuffer) 2499 return out, metadata, &smithy.DeserializationError{ 2500 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2501 Snapshot: snapshot.Bytes(), 2502 } 2503 } 2504 2505 return out, metadata, err 2506} 2507 2508func awsRestjson1_deserializeOpErrorListAccountIntegrations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2509 var errorBuffer bytes.Buffer 2510 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2511 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2512 } 2513 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2514 2515 errorCode := "UnknownError" 2516 errorMessage := errorCode 2517 2518 code := response.Header.Get("X-Amzn-ErrorType") 2519 if len(code) != 0 { 2520 errorCode = restjson.SanitizeErrorCode(code) 2521 } 2522 2523 var buff [1024]byte 2524 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2525 2526 body := io.TeeReader(errorBody, ringBuffer) 2527 decoder := json.NewDecoder(body) 2528 decoder.UseNumber() 2529 code, message, err := restjson.GetErrorInfo(decoder) 2530 if err != nil { 2531 var snapshot bytes.Buffer 2532 io.Copy(&snapshot, ringBuffer) 2533 err = &smithy.DeserializationError{ 2534 Err: fmt.Errorf("failed to decode response body, %w", err), 2535 Snapshot: snapshot.Bytes(), 2536 } 2537 return err 2538 } 2539 2540 errorBody.Seek(0, io.SeekStart) 2541 if len(code) != 0 { 2542 errorCode = restjson.SanitizeErrorCode(code) 2543 } 2544 if len(message) != 0 { 2545 errorMessage = message 2546 } 2547 2548 switch { 2549 case strings.EqualFold("AccessDeniedException", errorCode): 2550 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2551 2552 case strings.EqualFold("BadRequestException", errorCode): 2553 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2554 2555 case strings.EqualFold("InternalServerException", errorCode): 2556 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2557 2558 case strings.EqualFold("ResourceNotFoundException", errorCode): 2559 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2560 2561 case strings.EqualFold("ThrottlingException", errorCode): 2562 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2563 2564 default: 2565 genericError := &smithy.GenericAPIError{ 2566 Code: errorCode, 2567 Message: errorMessage, 2568 } 2569 return genericError 2570 2571 } 2572} 2573 2574func awsRestjson1_deserializeOpDocumentListAccountIntegrationsOutput(v **ListAccountIntegrationsOutput, value interface{}) error { 2575 if v == nil { 2576 return fmt.Errorf("unexpected nil of type %T", v) 2577 } 2578 if value == nil { 2579 return nil 2580 } 2581 2582 shape, ok := value.(map[string]interface{}) 2583 if !ok { 2584 return fmt.Errorf("unexpected JSON type %v", value) 2585 } 2586 2587 var sv *ListAccountIntegrationsOutput 2588 if *v == nil { 2589 sv = &ListAccountIntegrationsOutput{} 2590 } else { 2591 sv = *v 2592 } 2593 2594 for key, value := range shape { 2595 switch key { 2596 case "Items": 2597 if err := awsRestjson1_deserializeDocumentIntegrationList(&sv.Items, value); err != nil { 2598 return err 2599 } 2600 2601 case "NextToken": 2602 if value != nil { 2603 jtv, ok := value.(string) 2604 if !ok { 2605 return fmt.Errorf("expected token to be of type string, got %T instead", value) 2606 } 2607 sv.NextToken = ptr.String(jtv) 2608 } 2609 2610 default: 2611 _, _ = key, value 2612 2613 } 2614 } 2615 *v = sv 2616 return nil 2617} 2618 2619type awsRestjson1_deserializeOpListDomains struct { 2620} 2621 2622func (*awsRestjson1_deserializeOpListDomains) ID() string { 2623 return "OperationDeserializer" 2624} 2625 2626func (m *awsRestjson1_deserializeOpListDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2627 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2628) { 2629 out, metadata, err = next.HandleDeserialize(ctx, in) 2630 if err != nil { 2631 return out, metadata, err 2632 } 2633 2634 response, ok := out.RawResponse.(*smithyhttp.Response) 2635 if !ok { 2636 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2637 } 2638 2639 if response.StatusCode < 200 || response.StatusCode >= 300 { 2640 return out, metadata, awsRestjson1_deserializeOpErrorListDomains(response, &metadata) 2641 } 2642 output := &ListDomainsOutput{} 2643 out.Result = output 2644 2645 var buff [1024]byte 2646 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2647 2648 body := io.TeeReader(response.Body, ringBuffer) 2649 2650 decoder := json.NewDecoder(body) 2651 decoder.UseNumber() 2652 var shape interface{} 2653 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2654 var snapshot bytes.Buffer 2655 io.Copy(&snapshot, ringBuffer) 2656 err = &smithy.DeserializationError{ 2657 Err: fmt.Errorf("failed to decode response body, %w", err), 2658 Snapshot: snapshot.Bytes(), 2659 } 2660 return out, metadata, err 2661 } 2662 2663 err = awsRestjson1_deserializeOpDocumentListDomainsOutput(&output, shape) 2664 if err != nil { 2665 var snapshot bytes.Buffer 2666 io.Copy(&snapshot, ringBuffer) 2667 return out, metadata, &smithy.DeserializationError{ 2668 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2669 Snapshot: snapshot.Bytes(), 2670 } 2671 } 2672 2673 return out, metadata, err 2674} 2675 2676func awsRestjson1_deserializeOpErrorListDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2677 var errorBuffer bytes.Buffer 2678 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2679 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2680 } 2681 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2682 2683 errorCode := "UnknownError" 2684 errorMessage := errorCode 2685 2686 code := response.Header.Get("X-Amzn-ErrorType") 2687 if len(code) != 0 { 2688 errorCode = restjson.SanitizeErrorCode(code) 2689 } 2690 2691 var buff [1024]byte 2692 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2693 2694 body := io.TeeReader(errorBody, ringBuffer) 2695 decoder := json.NewDecoder(body) 2696 decoder.UseNumber() 2697 code, message, err := restjson.GetErrorInfo(decoder) 2698 if err != nil { 2699 var snapshot bytes.Buffer 2700 io.Copy(&snapshot, ringBuffer) 2701 err = &smithy.DeserializationError{ 2702 Err: fmt.Errorf("failed to decode response body, %w", err), 2703 Snapshot: snapshot.Bytes(), 2704 } 2705 return err 2706 } 2707 2708 errorBody.Seek(0, io.SeekStart) 2709 if len(code) != 0 { 2710 errorCode = restjson.SanitizeErrorCode(code) 2711 } 2712 if len(message) != 0 { 2713 errorMessage = message 2714 } 2715 2716 switch { 2717 case strings.EqualFold("AccessDeniedException", errorCode): 2718 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2719 2720 case strings.EqualFold("BadRequestException", errorCode): 2721 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2722 2723 case strings.EqualFold("InternalServerException", errorCode): 2724 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2725 2726 case strings.EqualFold("ResourceNotFoundException", errorCode): 2727 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2728 2729 case strings.EqualFold("ThrottlingException", errorCode): 2730 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2731 2732 default: 2733 genericError := &smithy.GenericAPIError{ 2734 Code: errorCode, 2735 Message: errorMessage, 2736 } 2737 return genericError 2738 2739 } 2740} 2741 2742func awsRestjson1_deserializeOpDocumentListDomainsOutput(v **ListDomainsOutput, value interface{}) error { 2743 if v == nil { 2744 return fmt.Errorf("unexpected nil of type %T", v) 2745 } 2746 if value == nil { 2747 return nil 2748 } 2749 2750 shape, ok := value.(map[string]interface{}) 2751 if !ok { 2752 return fmt.Errorf("unexpected JSON type %v", value) 2753 } 2754 2755 var sv *ListDomainsOutput 2756 if *v == nil { 2757 sv = &ListDomainsOutput{} 2758 } else { 2759 sv = *v 2760 } 2761 2762 for key, value := range shape { 2763 switch key { 2764 case "Items": 2765 if err := awsRestjson1_deserializeDocumentDomainList(&sv.Items, value); err != nil { 2766 return err 2767 } 2768 2769 case "NextToken": 2770 if value != nil { 2771 jtv, ok := value.(string) 2772 if !ok { 2773 return fmt.Errorf("expected token to be of type string, got %T instead", value) 2774 } 2775 sv.NextToken = ptr.String(jtv) 2776 } 2777 2778 default: 2779 _, _ = key, value 2780 2781 } 2782 } 2783 *v = sv 2784 return nil 2785} 2786 2787type awsRestjson1_deserializeOpListIntegrations struct { 2788} 2789 2790func (*awsRestjson1_deserializeOpListIntegrations) ID() string { 2791 return "OperationDeserializer" 2792} 2793 2794func (m *awsRestjson1_deserializeOpListIntegrations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2795 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2796) { 2797 out, metadata, err = next.HandleDeserialize(ctx, in) 2798 if err != nil { 2799 return out, metadata, err 2800 } 2801 2802 response, ok := out.RawResponse.(*smithyhttp.Response) 2803 if !ok { 2804 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2805 } 2806 2807 if response.StatusCode < 200 || response.StatusCode >= 300 { 2808 return out, metadata, awsRestjson1_deserializeOpErrorListIntegrations(response, &metadata) 2809 } 2810 output := &ListIntegrationsOutput{} 2811 out.Result = output 2812 2813 var buff [1024]byte 2814 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2815 2816 body := io.TeeReader(response.Body, ringBuffer) 2817 2818 decoder := json.NewDecoder(body) 2819 decoder.UseNumber() 2820 var shape interface{} 2821 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2822 var snapshot bytes.Buffer 2823 io.Copy(&snapshot, ringBuffer) 2824 err = &smithy.DeserializationError{ 2825 Err: fmt.Errorf("failed to decode response body, %w", err), 2826 Snapshot: snapshot.Bytes(), 2827 } 2828 return out, metadata, err 2829 } 2830 2831 err = awsRestjson1_deserializeOpDocumentListIntegrationsOutput(&output, shape) 2832 if err != nil { 2833 var snapshot bytes.Buffer 2834 io.Copy(&snapshot, ringBuffer) 2835 return out, metadata, &smithy.DeserializationError{ 2836 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2837 Snapshot: snapshot.Bytes(), 2838 } 2839 } 2840 2841 return out, metadata, err 2842} 2843 2844func awsRestjson1_deserializeOpErrorListIntegrations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2845 var errorBuffer bytes.Buffer 2846 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2847 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2848 } 2849 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2850 2851 errorCode := "UnknownError" 2852 errorMessage := errorCode 2853 2854 code := response.Header.Get("X-Amzn-ErrorType") 2855 if len(code) != 0 { 2856 errorCode = restjson.SanitizeErrorCode(code) 2857 } 2858 2859 var buff [1024]byte 2860 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2861 2862 body := io.TeeReader(errorBody, ringBuffer) 2863 decoder := json.NewDecoder(body) 2864 decoder.UseNumber() 2865 code, message, err := restjson.GetErrorInfo(decoder) 2866 if err != nil { 2867 var snapshot bytes.Buffer 2868 io.Copy(&snapshot, ringBuffer) 2869 err = &smithy.DeserializationError{ 2870 Err: fmt.Errorf("failed to decode response body, %w", err), 2871 Snapshot: snapshot.Bytes(), 2872 } 2873 return err 2874 } 2875 2876 errorBody.Seek(0, io.SeekStart) 2877 if len(code) != 0 { 2878 errorCode = restjson.SanitizeErrorCode(code) 2879 } 2880 if len(message) != 0 { 2881 errorMessage = message 2882 } 2883 2884 switch { 2885 case strings.EqualFold("AccessDeniedException", errorCode): 2886 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2887 2888 case strings.EqualFold("BadRequestException", errorCode): 2889 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2890 2891 case strings.EqualFold("InternalServerException", errorCode): 2892 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2893 2894 case strings.EqualFold("ResourceNotFoundException", errorCode): 2895 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2896 2897 case strings.EqualFold("ThrottlingException", errorCode): 2898 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 2899 2900 default: 2901 genericError := &smithy.GenericAPIError{ 2902 Code: errorCode, 2903 Message: errorMessage, 2904 } 2905 return genericError 2906 2907 } 2908} 2909 2910func awsRestjson1_deserializeOpDocumentListIntegrationsOutput(v **ListIntegrationsOutput, value interface{}) error { 2911 if v == nil { 2912 return fmt.Errorf("unexpected nil of type %T", v) 2913 } 2914 if value == nil { 2915 return nil 2916 } 2917 2918 shape, ok := value.(map[string]interface{}) 2919 if !ok { 2920 return fmt.Errorf("unexpected JSON type %v", value) 2921 } 2922 2923 var sv *ListIntegrationsOutput 2924 if *v == nil { 2925 sv = &ListIntegrationsOutput{} 2926 } else { 2927 sv = *v 2928 } 2929 2930 for key, value := range shape { 2931 switch key { 2932 case "Items": 2933 if err := awsRestjson1_deserializeDocumentIntegrationList(&sv.Items, value); err != nil { 2934 return err 2935 } 2936 2937 case "NextToken": 2938 if value != nil { 2939 jtv, ok := value.(string) 2940 if !ok { 2941 return fmt.Errorf("expected token to be of type string, got %T instead", value) 2942 } 2943 sv.NextToken = ptr.String(jtv) 2944 } 2945 2946 default: 2947 _, _ = key, value 2948 2949 } 2950 } 2951 *v = sv 2952 return nil 2953} 2954 2955type awsRestjson1_deserializeOpListProfileObjects struct { 2956} 2957 2958func (*awsRestjson1_deserializeOpListProfileObjects) ID() string { 2959 return "OperationDeserializer" 2960} 2961 2962func (m *awsRestjson1_deserializeOpListProfileObjects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2963 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2964) { 2965 out, metadata, err = next.HandleDeserialize(ctx, in) 2966 if err != nil { 2967 return out, metadata, err 2968 } 2969 2970 response, ok := out.RawResponse.(*smithyhttp.Response) 2971 if !ok { 2972 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2973 } 2974 2975 if response.StatusCode < 200 || response.StatusCode >= 300 { 2976 return out, metadata, awsRestjson1_deserializeOpErrorListProfileObjects(response, &metadata) 2977 } 2978 output := &ListProfileObjectsOutput{} 2979 out.Result = output 2980 2981 var buff [1024]byte 2982 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2983 2984 body := io.TeeReader(response.Body, ringBuffer) 2985 2986 decoder := json.NewDecoder(body) 2987 decoder.UseNumber() 2988 var shape interface{} 2989 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2990 var snapshot bytes.Buffer 2991 io.Copy(&snapshot, ringBuffer) 2992 err = &smithy.DeserializationError{ 2993 Err: fmt.Errorf("failed to decode response body, %w", err), 2994 Snapshot: snapshot.Bytes(), 2995 } 2996 return out, metadata, err 2997 } 2998 2999 err = awsRestjson1_deserializeOpDocumentListProfileObjectsOutput(&output, shape) 3000 if err != nil { 3001 var snapshot bytes.Buffer 3002 io.Copy(&snapshot, ringBuffer) 3003 return out, metadata, &smithy.DeserializationError{ 3004 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3005 Snapshot: snapshot.Bytes(), 3006 } 3007 } 3008 3009 return out, metadata, err 3010} 3011 3012func awsRestjson1_deserializeOpErrorListProfileObjects(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3013 var errorBuffer bytes.Buffer 3014 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3015 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3016 } 3017 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3018 3019 errorCode := "UnknownError" 3020 errorMessage := errorCode 3021 3022 code := response.Header.Get("X-Amzn-ErrorType") 3023 if len(code) != 0 { 3024 errorCode = restjson.SanitizeErrorCode(code) 3025 } 3026 3027 var buff [1024]byte 3028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3029 3030 body := io.TeeReader(errorBody, ringBuffer) 3031 decoder := json.NewDecoder(body) 3032 decoder.UseNumber() 3033 code, message, err := restjson.GetErrorInfo(decoder) 3034 if err != nil { 3035 var snapshot bytes.Buffer 3036 io.Copy(&snapshot, ringBuffer) 3037 err = &smithy.DeserializationError{ 3038 Err: fmt.Errorf("failed to decode response body, %w", err), 3039 Snapshot: snapshot.Bytes(), 3040 } 3041 return err 3042 } 3043 3044 errorBody.Seek(0, io.SeekStart) 3045 if len(code) != 0 { 3046 errorCode = restjson.SanitizeErrorCode(code) 3047 } 3048 if len(message) != 0 { 3049 errorMessage = message 3050 } 3051 3052 switch { 3053 case strings.EqualFold("AccessDeniedException", errorCode): 3054 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3055 3056 case strings.EqualFold("BadRequestException", errorCode): 3057 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3058 3059 case strings.EqualFold("InternalServerException", errorCode): 3060 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3061 3062 case strings.EqualFold("ResourceNotFoundException", errorCode): 3063 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3064 3065 case strings.EqualFold("ThrottlingException", errorCode): 3066 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3067 3068 default: 3069 genericError := &smithy.GenericAPIError{ 3070 Code: errorCode, 3071 Message: errorMessage, 3072 } 3073 return genericError 3074 3075 } 3076} 3077 3078func awsRestjson1_deserializeOpDocumentListProfileObjectsOutput(v **ListProfileObjectsOutput, value interface{}) error { 3079 if v == nil { 3080 return fmt.Errorf("unexpected nil of type %T", v) 3081 } 3082 if value == nil { 3083 return nil 3084 } 3085 3086 shape, ok := value.(map[string]interface{}) 3087 if !ok { 3088 return fmt.Errorf("unexpected JSON type %v", value) 3089 } 3090 3091 var sv *ListProfileObjectsOutput 3092 if *v == nil { 3093 sv = &ListProfileObjectsOutput{} 3094 } else { 3095 sv = *v 3096 } 3097 3098 for key, value := range shape { 3099 switch key { 3100 case "Items": 3101 if err := awsRestjson1_deserializeDocumentProfileObjectList(&sv.Items, value); err != nil { 3102 return err 3103 } 3104 3105 case "NextToken": 3106 if value != nil { 3107 jtv, ok := value.(string) 3108 if !ok { 3109 return fmt.Errorf("expected token to be of type string, got %T instead", value) 3110 } 3111 sv.NextToken = ptr.String(jtv) 3112 } 3113 3114 default: 3115 _, _ = key, value 3116 3117 } 3118 } 3119 *v = sv 3120 return nil 3121} 3122 3123type awsRestjson1_deserializeOpListProfileObjectTypes struct { 3124} 3125 3126func (*awsRestjson1_deserializeOpListProfileObjectTypes) ID() string { 3127 return "OperationDeserializer" 3128} 3129 3130func (m *awsRestjson1_deserializeOpListProfileObjectTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3131 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3132) { 3133 out, metadata, err = next.HandleDeserialize(ctx, in) 3134 if err != nil { 3135 return out, metadata, err 3136 } 3137 3138 response, ok := out.RawResponse.(*smithyhttp.Response) 3139 if !ok { 3140 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3141 } 3142 3143 if response.StatusCode < 200 || response.StatusCode >= 300 { 3144 return out, metadata, awsRestjson1_deserializeOpErrorListProfileObjectTypes(response, &metadata) 3145 } 3146 output := &ListProfileObjectTypesOutput{} 3147 out.Result = output 3148 3149 var buff [1024]byte 3150 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3151 3152 body := io.TeeReader(response.Body, ringBuffer) 3153 3154 decoder := json.NewDecoder(body) 3155 decoder.UseNumber() 3156 var shape interface{} 3157 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3158 var snapshot bytes.Buffer 3159 io.Copy(&snapshot, ringBuffer) 3160 err = &smithy.DeserializationError{ 3161 Err: fmt.Errorf("failed to decode response body, %w", err), 3162 Snapshot: snapshot.Bytes(), 3163 } 3164 return out, metadata, err 3165 } 3166 3167 err = awsRestjson1_deserializeOpDocumentListProfileObjectTypesOutput(&output, shape) 3168 if err != nil { 3169 var snapshot bytes.Buffer 3170 io.Copy(&snapshot, ringBuffer) 3171 return out, metadata, &smithy.DeserializationError{ 3172 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3173 Snapshot: snapshot.Bytes(), 3174 } 3175 } 3176 3177 return out, metadata, err 3178} 3179 3180func awsRestjson1_deserializeOpErrorListProfileObjectTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3181 var errorBuffer bytes.Buffer 3182 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3183 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3184 } 3185 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3186 3187 errorCode := "UnknownError" 3188 errorMessage := errorCode 3189 3190 code := response.Header.Get("X-Amzn-ErrorType") 3191 if len(code) != 0 { 3192 errorCode = restjson.SanitizeErrorCode(code) 3193 } 3194 3195 var buff [1024]byte 3196 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3197 3198 body := io.TeeReader(errorBody, ringBuffer) 3199 decoder := json.NewDecoder(body) 3200 decoder.UseNumber() 3201 code, message, err := restjson.GetErrorInfo(decoder) 3202 if err != nil { 3203 var snapshot bytes.Buffer 3204 io.Copy(&snapshot, ringBuffer) 3205 err = &smithy.DeserializationError{ 3206 Err: fmt.Errorf("failed to decode response body, %w", err), 3207 Snapshot: snapshot.Bytes(), 3208 } 3209 return err 3210 } 3211 3212 errorBody.Seek(0, io.SeekStart) 3213 if len(code) != 0 { 3214 errorCode = restjson.SanitizeErrorCode(code) 3215 } 3216 if len(message) != 0 { 3217 errorMessage = message 3218 } 3219 3220 switch { 3221 case strings.EqualFold("AccessDeniedException", errorCode): 3222 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3223 3224 case strings.EqualFold("BadRequestException", errorCode): 3225 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3226 3227 case strings.EqualFold("InternalServerException", errorCode): 3228 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3229 3230 case strings.EqualFold("ResourceNotFoundException", errorCode): 3231 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3232 3233 case strings.EqualFold("ThrottlingException", errorCode): 3234 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3235 3236 default: 3237 genericError := &smithy.GenericAPIError{ 3238 Code: errorCode, 3239 Message: errorMessage, 3240 } 3241 return genericError 3242 3243 } 3244} 3245 3246func awsRestjson1_deserializeOpDocumentListProfileObjectTypesOutput(v **ListProfileObjectTypesOutput, value interface{}) error { 3247 if v == nil { 3248 return fmt.Errorf("unexpected nil of type %T", v) 3249 } 3250 if value == nil { 3251 return nil 3252 } 3253 3254 shape, ok := value.(map[string]interface{}) 3255 if !ok { 3256 return fmt.Errorf("unexpected JSON type %v", value) 3257 } 3258 3259 var sv *ListProfileObjectTypesOutput 3260 if *v == nil { 3261 sv = &ListProfileObjectTypesOutput{} 3262 } else { 3263 sv = *v 3264 } 3265 3266 for key, value := range shape { 3267 switch key { 3268 case "Items": 3269 if err := awsRestjson1_deserializeDocumentProfileObjectTypeList(&sv.Items, value); err != nil { 3270 return err 3271 } 3272 3273 case "NextToken": 3274 if value != nil { 3275 jtv, ok := value.(string) 3276 if !ok { 3277 return fmt.Errorf("expected token to be of type string, got %T instead", value) 3278 } 3279 sv.NextToken = ptr.String(jtv) 3280 } 3281 3282 default: 3283 _, _ = key, value 3284 3285 } 3286 } 3287 *v = sv 3288 return nil 3289} 3290 3291type awsRestjson1_deserializeOpListProfileObjectTypeTemplates struct { 3292} 3293 3294func (*awsRestjson1_deserializeOpListProfileObjectTypeTemplates) ID() string { 3295 return "OperationDeserializer" 3296} 3297 3298func (m *awsRestjson1_deserializeOpListProfileObjectTypeTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3299 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3300) { 3301 out, metadata, err = next.HandleDeserialize(ctx, in) 3302 if err != nil { 3303 return out, metadata, err 3304 } 3305 3306 response, ok := out.RawResponse.(*smithyhttp.Response) 3307 if !ok { 3308 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3309 } 3310 3311 if response.StatusCode < 200 || response.StatusCode >= 300 { 3312 return out, metadata, awsRestjson1_deserializeOpErrorListProfileObjectTypeTemplates(response, &metadata) 3313 } 3314 output := &ListProfileObjectTypeTemplatesOutput{} 3315 out.Result = output 3316 3317 var buff [1024]byte 3318 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3319 3320 body := io.TeeReader(response.Body, ringBuffer) 3321 3322 decoder := json.NewDecoder(body) 3323 decoder.UseNumber() 3324 var shape interface{} 3325 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3326 var snapshot bytes.Buffer 3327 io.Copy(&snapshot, ringBuffer) 3328 err = &smithy.DeserializationError{ 3329 Err: fmt.Errorf("failed to decode response body, %w", err), 3330 Snapshot: snapshot.Bytes(), 3331 } 3332 return out, metadata, err 3333 } 3334 3335 err = awsRestjson1_deserializeOpDocumentListProfileObjectTypeTemplatesOutput(&output, shape) 3336 if err != nil { 3337 var snapshot bytes.Buffer 3338 io.Copy(&snapshot, ringBuffer) 3339 return out, metadata, &smithy.DeserializationError{ 3340 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3341 Snapshot: snapshot.Bytes(), 3342 } 3343 } 3344 3345 return out, metadata, err 3346} 3347 3348func awsRestjson1_deserializeOpErrorListProfileObjectTypeTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3349 var errorBuffer bytes.Buffer 3350 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3351 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3352 } 3353 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3354 3355 errorCode := "UnknownError" 3356 errorMessage := errorCode 3357 3358 code := response.Header.Get("X-Amzn-ErrorType") 3359 if len(code) != 0 { 3360 errorCode = restjson.SanitizeErrorCode(code) 3361 } 3362 3363 var buff [1024]byte 3364 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3365 3366 body := io.TeeReader(errorBody, ringBuffer) 3367 decoder := json.NewDecoder(body) 3368 decoder.UseNumber() 3369 code, message, err := restjson.GetErrorInfo(decoder) 3370 if err != nil { 3371 var snapshot bytes.Buffer 3372 io.Copy(&snapshot, ringBuffer) 3373 err = &smithy.DeserializationError{ 3374 Err: fmt.Errorf("failed to decode response body, %w", err), 3375 Snapshot: snapshot.Bytes(), 3376 } 3377 return err 3378 } 3379 3380 errorBody.Seek(0, io.SeekStart) 3381 if len(code) != 0 { 3382 errorCode = restjson.SanitizeErrorCode(code) 3383 } 3384 if len(message) != 0 { 3385 errorMessage = message 3386 } 3387 3388 switch { 3389 case strings.EqualFold("AccessDeniedException", errorCode): 3390 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3391 3392 case strings.EqualFold("BadRequestException", errorCode): 3393 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3394 3395 case strings.EqualFold("InternalServerException", errorCode): 3396 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3397 3398 case strings.EqualFold("ResourceNotFoundException", errorCode): 3399 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3400 3401 case strings.EqualFold("ThrottlingException", errorCode): 3402 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3403 3404 default: 3405 genericError := &smithy.GenericAPIError{ 3406 Code: errorCode, 3407 Message: errorMessage, 3408 } 3409 return genericError 3410 3411 } 3412} 3413 3414func awsRestjson1_deserializeOpDocumentListProfileObjectTypeTemplatesOutput(v **ListProfileObjectTypeTemplatesOutput, value interface{}) error { 3415 if v == nil { 3416 return fmt.Errorf("unexpected nil of type %T", v) 3417 } 3418 if value == nil { 3419 return nil 3420 } 3421 3422 shape, ok := value.(map[string]interface{}) 3423 if !ok { 3424 return fmt.Errorf("unexpected JSON type %v", value) 3425 } 3426 3427 var sv *ListProfileObjectTypeTemplatesOutput 3428 if *v == nil { 3429 sv = &ListProfileObjectTypeTemplatesOutput{} 3430 } else { 3431 sv = *v 3432 } 3433 3434 for key, value := range shape { 3435 switch key { 3436 case "Items": 3437 if err := awsRestjson1_deserializeDocumentProfileObjectTypeTemplateList(&sv.Items, value); err != nil { 3438 return err 3439 } 3440 3441 case "NextToken": 3442 if value != nil { 3443 jtv, ok := value.(string) 3444 if !ok { 3445 return fmt.Errorf("expected token to be of type string, got %T instead", value) 3446 } 3447 sv.NextToken = ptr.String(jtv) 3448 } 3449 3450 default: 3451 _, _ = key, value 3452 3453 } 3454 } 3455 *v = sv 3456 return nil 3457} 3458 3459type awsRestjson1_deserializeOpListTagsForResource struct { 3460} 3461 3462func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 3463 return "OperationDeserializer" 3464} 3465 3466func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3467 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3468) { 3469 out, metadata, err = next.HandleDeserialize(ctx, in) 3470 if err != nil { 3471 return out, metadata, err 3472 } 3473 3474 response, ok := out.RawResponse.(*smithyhttp.Response) 3475 if !ok { 3476 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3477 } 3478 3479 if response.StatusCode < 200 || response.StatusCode >= 300 { 3480 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 3481 } 3482 output := &ListTagsForResourceOutput{} 3483 out.Result = output 3484 3485 var buff [1024]byte 3486 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3487 3488 body := io.TeeReader(response.Body, ringBuffer) 3489 3490 decoder := json.NewDecoder(body) 3491 decoder.UseNumber() 3492 var shape interface{} 3493 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3494 var snapshot bytes.Buffer 3495 io.Copy(&snapshot, ringBuffer) 3496 err = &smithy.DeserializationError{ 3497 Err: fmt.Errorf("failed to decode response body, %w", err), 3498 Snapshot: snapshot.Bytes(), 3499 } 3500 return out, metadata, err 3501 } 3502 3503 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 3504 if err != nil { 3505 var snapshot bytes.Buffer 3506 io.Copy(&snapshot, ringBuffer) 3507 return out, metadata, &smithy.DeserializationError{ 3508 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3509 Snapshot: snapshot.Bytes(), 3510 } 3511 } 3512 3513 return out, metadata, err 3514} 3515 3516func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3517 var errorBuffer bytes.Buffer 3518 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3519 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3520 } 3521 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3522 3523 errorCode := "UnknownError" 3524 errorMessage := errorCode 3525 3526 code := response.Header.Get("X-Amzn-ErrorType") 3527 if len(code) != 0 { 3528 errorCode = restjson.SanitizeErrorCode(code) 3529 } 3530 3531 var buff [1024]byte 3532 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3533 3534 body := io.TeeReader(errorBody, ringBuffer) 3535 decoder := json.NewDecoder(body) 3536 decoder.UseNumber() 3537 code, message, err := restjson.GetErrorInfo(decoder) 3538 if err != nil { 3539 var snapshot bytes.Buffer 3540 io.Copy(&snapshot, ringBuffer) 3541 err = &smithy.DeserializationError{ 3542 Err: fmt.Errorf("failed to decode response body, %w", err), 3543 Snapshot: snapshot.Bytes(), 3544 } 3545 return err 3546 } 3547 3548 errorBody.Seek(0, io.SeekStart) 3549 if len(code) != 0 { 3550 errorCode = restjson.SanitizeErrorCode(code) 3551 } 3552 if len(message) != 0 { 3553 errorMessage = message 3554 } 3555 3556 switch { 3557 case strings.EqualFold("BadRequestException", errorCode): 3558 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3559 3560 case strings.EqualFold("InternalServerException", errorCode): 3561 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3562 3563 case strings.EqualFold("ResourceNotFoundException", errorCode): 3564 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3565 3566 default: 3567 genericError := &smithy.GenericAPIError{ 3568 Code: errorCode, 3569 Message: errorMessage, 3570 } 3571 return genericError 3572 3573 } 3574} 3575 3576func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 3577 if v == nil { 3578 return fmt.Errorf("unexpected nil of type %T", v) 3579 } 3580 if value == nil { 3581 return nil 3582 } 3583 3584 shape, ok := value.(map[string]interface{}) 3585 if !ok { 3586 return fmt.Errorf("unexpected JSON type %v", value) 3587 } 3588 3589 var sv *ListTagsForResourceOutput 3590 if *v == nil { 3591 sv = &ListTagsForResourceOutput{} 3592 } else { 3593 sv = *v 3594 } 3595 3596 for key, value := range shape { 3597 switch key { 3598 case "tags": 3599 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 3600 return err 3601 } 3602 3603 default: 3604 _, _ = key, value 3605 3606 } 3607 } 3608 *v = sv 3609 return nil 3610} 3611 3612type awsRestjson1_deserializeOpPutIntegration struct { 3613} 3614 3615func (*awsRestjson1_deserializeOpPutIntegration) ID() string { 3616 return "OperationDeserializer" 3617} 3618 3619func (m *awsRestjson1_deserializeOpPutIntegration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3620 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3621) { 3622 out, metadata, err = next.HandleDeserialize(ctx, in) 3623 if err != nil { 3624 return out, metadata, err 3625 } 3626 3627 response, ok := out.RawResponse.(*smithyhttp.Response) 3628 if !ok { 3629 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3630 } 3631 3632 if response.StatusCode < 200 || response.StatusCode >= 300 { 3633 return out, metadata, awsRestjson1_deserializeOpErrorPutIntegration(response, &metadata) 3634 } 3635 output := &PutIntegrationOutput{} 3636 out.Result = output 3637 3638 var buff [1024]byte 3639 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3640 3641 body := io.TeeReader(response.Body, ringBuffer) 3642 3643 decoder := json.NewDecoder(body) 3644 decoder.UseNumber() 3645 var shape interface{} 3646 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3647 var snapshot bytes.Buffer 3648 io.Copy(&snapshot, ringBuffer) 3649 err = &smithy.DeserializationError{ 3650 Err: fmt.Errorf("failed to decode response body, %w", err), 3651 Snapshot: snapshot.Bytes(), 3652 } 3653 return out, metadata, err 3654 } 3655 3656 err = awsRestjson1_deserializeOpDocumentPutIntegrationOutput(&output, shape) 3657 if err != nil { 3658 var snapshot bytes.Buffer 3659 io.Copy(&snapshot, ringBuffer) 3660 return out, metadata, &smithy.DeserializationError{ 3661 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3662 Snapshot: snapshot.Bytes(), 3663 } 3664 } 3665 3666 return out, metadata, err 3667} 3668 3669func awsRestjson1_deserializeOpErrorPutIntegration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3670 var errorBuffer bytes.Buffer 3671 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3672 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3673 } 3674 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3675 3676 errorCode := "UnknownError" 3677 errorMessage := errorCode 3678 3679 code := response.Header.Get("X-Amzn-ErrorType") 3680 if len(code) != 0 { 3681 errorCode = restjson.SanitizeErrorCode(code) 3682 } 3683 3684 var buff [1024]byte 3685 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3686 3687 body := io.TeeReader(errorBody, ringBuffer) 3688 decoder := json.NewDecoder(body) 3689 decoder.UseNumber() 3690 code, message, err := restjson.GetErrorInfo(decoder) 3691 if err != nil { 3692 var snapshot bytes.Buffer 3693 io.Copy(&snapshot, ringBuffer) 3694 err = &smithy.DeserializationError{ 3695 Err: fmt.Errorf("failed to decode response body, %w", err), 3696 Snapshot: snapshot.Bytes(), 3697 } 3698 return err 3699 } 3700 3701 errorBody.Seek(0, io.SeekStart) 3702 if len(code) != 0 { 3703 errorCode = restjson.SanitizeErrorCode(code) 3704 } 3705 if len(message) != 0 { 3706 errorMessage = message 3707 } 3708 3709 switch { 3710 case strings.EqualFold("AccessDeniedException", errorCode): 3711 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3712 3713 case strings.EqualFold("BadRequestException", errorCode): 3714 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3715 3716 case strings.EqualFold("InternalServerException", errorCode): 3717 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3718 3719 case strings.EqualFold("ResourceNotFoundException", errorCode): 3720 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3721 3722 case strings.EqualFold("ThrottlingException", errorCode): 3723 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3724 3725 default: 3726 genericError := &smithy.GenericAPIError{ 3727 Code: errorCode, 3728 Message: errorMessage, 3729 } 3730 return genericError 3731 3732 } 3733} 3734 3735func awsRestjson1_deserializeOpDocumentPutIntegrationOutput(v **PutIntegrationOutput, value interface{}) error { 3736 if v == nil { 3737 return fmt.Errorf("unexpected nil of type %T", v) 3738 } 3739 if value == nil { 3740 return nil 3741 } 3742 3743 shape, ok := value.(map[string]interface{}) 3744 if !ok { 3745 return fmt.Errorf("unexpected JSON type %v", value) 3746 } 3747 3748 var sv *PutIntegrationOutput 3749 if *v == nil { 3750 sv = &PutIntegrationOutput{} 3751 } else { 3752 sv = *v 3753 } 3754 3755 for key, value := range shape { 3756 switch key { 3757 case "CreatedAt": 3758 if value != nil { 3759 jtv, ok := value.(json.Number) 3760 if !ok { 3761 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 3762 } 3763 f64, err := jtv.Float64() 3764 if err != nil { 3765 return err 3766 } 3767 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3768 } 3769 3770 case "DomainName": 3771 if value != nil { 3772 jtv, ok := value.(string) 3773 if !ok { 3774 return fmt.Errorf("expected name to be of type string, got %T instead", value) 3775 } 3776 sv.DomainName = ptr.String(jtv) 3777 } 3778 3779 case "LastUpdatedAt": 3780 if value != nil { 3781 jtv, ok := value.(json.Number) 3782 if !ok { 3783 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 3784 } 3785 f64, err := jtv.Float64() 3786 if err != nil { 3787 return err 3788 } 3789 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3790 } 3791 3792 case "ObjectTypeName": 3793 if value != nil { 3794 jtv, ok := value.(string) 3795 if !ok { 3796 return fmt.Errorf("expected typeName to be of type string, got %T instead", value) 3797 } 3798 sv.ObjectTypeName = ptr.String(jtv) 3799 } 3800 3801 case "Tags": 3802 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 3803 return err 3804 } 3805 3806 case "Uri": 3807 if value != nil { 3808 jtv, ok := value.(string) 3809 if !ok { 3810 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 3811 } 3812 sv.Uri = ptr.String(jtv) 3813 } 3814 3815 default: 3816 _, _ = key, value 3817 3818 } 3819 } 3820 *v = sv 3821 return nil 3822} 3823 3824type awsRestjson1_deserializeOpPutProfileObject struct { 3825} 3826 3827func (*awsRestjson1_deserializeOpPutProfileObject) ID() string { 3828 return "OperationDeserializer" 3829} 3830 3831func (m *awsRestjson1_deserializeOpPutProfileObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3832 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3833) { 3834 out, metadata, err = next.HandleDeserialize(ctx, in) 3835 if err != nil { 3836 return out, metadata, err 3837 } 3838 3839 response, ok := out.RawResponse.(*smithyhttp.Response) 3840 if !ok { 3841 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3842 } 3843 3844 if response.StatusCode < 200 || response.StatusCode >= 300 { 3845 return out, metadata, awsRestjson1_deserializeOpErrorPutProfileObject(response, &metadata) 3846 } 3847 output := &PutProfileObjectOutput{} 3848 out.Result = output 3849 3850 var buff [1024]byte 3851 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3852 3853 body := io.TeeReader(response.Body, ringBuffer) 3854 3855 decoder := json.NewDecoder(body) 3856 decoder.UseNumber() 3857 var shape interface{} 3858 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3859 var snapshot bytes.Buffer 3860 io.Copy(&snapshot, ringBuffer) 3861 err = &smithy.DeserializationError{ 3862 Err: fmt.Errorf("failed to decode response body, %w", err), 3863 Snapshot: snapshot.Bytes(), 3864 } 3865 return out, metadata, err 3866 } 3867 3868 err = awsRestjson1_deserializeOpDocumentPutProfileObjectOutput(&output, shape) 3869 if err != nil { 3870 var snapshot bytes.Buffer 3871 io.Copy(&snapshot, ringBuffer) 3872 return out, metadata, &smithy.DeserializationError{ 3873 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3874 Snapshot: snapshot.Bytes(), 3875 } 3876 } 3877 3878 return out, metadata, err 3879} 3880 3881func awsRestjson1_deserializeOpErrorPutProfileObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3882 var errorBuffer bytes.Buffer 3883 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3884 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3885 } 3886 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3887 3888 errorCode := "UnknownError" 3889 errorMessage := errorCode 3890 3891 code := response.Header.Get("X-Amzn-ErrorType") 3892 if len(code) != 0 { 3893 errorCode = restjson.SanitizeErrorCode(code) 3894 } 3895 3896 var buff [1024]byte 3897 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3898 3899 body := io.TeeReader(errorBody, ringBuffer) 3900 decoder := json.NewDecoder(body) 3901 decoder.UseNumber() 3902 code, message, err := restjson.GetErrorInfo(decoder) 3903 if err != nil { 3904 var snapshot bytes.Buffer 3905 io.Copy(&snapshot, ringBuffer) 3906 err = &smithy.DeserializationError{ 3907 Err: fmt.Errorf("failed to decode response body, %w", err), 3908 Snapshot: snapshot.Bytes(), 3909 } 3910 return err 3911 } 3912 3913 errorBody.Seek(0, io.SeekStart) 3914 if len(code) != 0 { 3915 errorCode = restjson.SanitizeErrorCode(code) 3916 } 3917 if len(message) != 0 { 3918 errorMessage = message 3919 } 3920 3921 switch { 3922 case strings.EqualFold("AccessDeniedException", errorCode): 3923 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3924 3925 case strings.EqualFold("BadRequestException", errorCode): 3926 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3927 3928 case strings.EqualFold("InternalServerException", errorCode): 3929 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3930 3931 case strings.EqualFold("ResourceNotFoundException", errorCode): 3932 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3933 3934 case strings.EqualFold("ThrottlingException", errorCode): 3935 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3936 3937 default: 3938 genericError := &smithy.GenericAPIError{ 3939 Code: errorCode, 3940 Message: errorMessage, 3941 } 3942 return genericError 3943 3944 } 3945} 3946 3947func awsRestjson1_deserializeOpDocumentPutProfileObjectOutput(v **PutProfileObjectOutput, value interface{}) error { 3948 if v == nil { 3949 return fmt.Errorf("unexpected nil of type %T", v) 3950 } 3951 if value == nil { 3952 return nil 3953 } 3954 3955 shape, ok := value.(map[string]interface{}) 3956 if !ok { 3957 return fmt.Errorf("unexpected JSON type %v", value) 3958 } 3959 3960 var sv *PutProfileObjectOutput 3961 if *v == nil { 3962 sv = &PutProfileObjectOutput{} 3963 } else { 3964 sv = *v 3965 } 3966 3967 for key, value := range shape { 3968 switch key { 3969 case "ProfileObjectUniqueKey": 3970 if value != nil { 3971 jtv, ok := value.(string) 3972 if !ok { 3973 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 3974 } 3975 sv.ProfileObjectUniqueKey = ptr.String(jtv) 3976 } 3977 3978 default: 3979 _, _ = key, value 3980 3981 } 3982 } 3983 *v = sv 3984 return nil 3985} 3986 3987type awsRestjson1_deserializeOpPutProfileObjectType struct { 3988} 3989 3990func (*awsRestjson1_deserializeOpPutProfileObjectType) ID() string { 3991 return "OperationDeserializer" 3992} 3993 3994func (m *awsRestjson1_deserializeOpPutProfileObjectType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3995 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3996) { 3997 out, metadata, err = next.HandleDeserialize(ctx, in) 3998 if err != nil { 3999 return out, metadata, err 4000 } 4001 4002 response, ok := out.RawResponse.(*smithyhttp.Response) 4003 if !ok { 4004 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4005 } 4006 4007 if response.StatusCode < 200 || response.StatusCode >= 300 { 4008 return out, metadata, awsRestjson1_deserializeOpErrorPutProfileObjectType(response, &metadata) 4009 } 4010 output := &PutProfileObjectTypeOutput{} 4011 out.Result = output 4012 4013 var buff [1024]byte 4014 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4015 4016 body := io.TeeReader(response.Body, ringBuffer) 4017 4018 decoder := json.NewDecoder(body) 4019 decoder.UseNumber() 4020 var shape interface{} 4021 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4022 var snapshot bytes.Buffer 4023 io.Copy(&snapshot, ringBuffer) 4024 err = &smithy.DeserializationError{ 4025 Err: fmt.Errorf("failed to decode response body, %w", err), 4026 Snapshot: snapshot.Bytes(), 4027 } 4028 return out, metadata, err 4029 } 4030 4031 err = awsRestjson1_deserializeOpDocumentPutProfileObjectTypeOutput(&output, shape) 4032 if err != nil { 4033 var snapshot bytes.Buffer 4034 io.Copy(&snapshot, ringBuffer) 4035 return out, metadata, &smithy.DeserializationError{ 4036 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4037 Snapshot: snapshot.Bytes(), 4038 } 4039 } 4040 4041 return out, metadata, err 4042} 4043 4044func awsRestjson1_deserializeOpErrorPutProfileObjectType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4045 var errorBuffer bytes.Buffer 4046 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4047 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4048 } 4049 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4050 4051 errorCode := "UnknownError" 4052 errorMessage := errorCode 4053 4054 code := response.Header.Get("X-Amzn-ErrorType") 4055 if len(code) != 0 { 4056 errorCode = restjson.SanitizeErrorCode(code) 4057 } 4058 4059 var buff [1024]byte 4060 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4061 4062 body := io.TeeReader(errorBody, ringBuffer) 4063 decoder := json.NewDecoder(body) 4064 decoder.UseNumber() 4065 code, message, err := restjson.GetErrorInfo(decoder) 4066 if err != nil { 4067 var snapshot bytes.Buffer 4068 io.Copy(&snapshot, ringBuffer) 4069 err = &smithy.DeserializationError{ 4070 Err: fmt.Errorf("failed to decode response body, %w", err), 4071 Snapshot: snapshot.Bytes(), 4072 } 4073 return err 4074 } 4075 4076 errorBody.Seek(0, io.SeekStart) 4077 if len(code) != 0 { 4078 errorCode = restjson.SanitizeErrorCode(code) 4079 } 4080 if len(message) != 0 { 4081 errorMessage = message 4082 } 4083 4084 switch { 4085 case strings.EqualFold("AccessDeniedException", errorCode): 4086 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4087 4088 case strings.EqualFold("BadRequestException", errorCode): 4089 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4090 4091 case strings.EqualFold("InternalServerException", errorCode): 4092 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4093 4094 case strings.EqualFold("ResourceNotFoundException", errorCode): 4095 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4096 4097 case strings.EqualFold("ThrottlingException", errorCode): 4098 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4099 4100 default: 4101 genericError := &smithy.GenericAPIError{ 4102 Code: errorCode, 4103 Message: errorMessage, 4104 } 4105 return genericError 4106 4107 } 4108} 4109 4110func awsRestjson1_deserializeOpDocumentPutProfileObjectTypeOutput(v **PutProfileObjectTypeOutput, value interface{}) error { 4111 if v == nil { 4112 return fmt.Errorf("unexpected nil of type %T", v) 4113 } 4114 if value == nil { 4115 return nil 4116 } 4117 4118 shape, ok := value.(map[string]interface{}) 4119 if !ok { 4120 return fmt.Errorf("unexpected JSON type %v", value) 4121 } 4122 4123 var sv *PutProfileObjectTypeOutput 4124 if *v == nil { 4125 sv = &PutProfileObjectTypeOutput{} 4126 } else { 4127 sv = *v 4128 } 4129 4130 for key, value := range shape { 4131 switch key { 4132 case "AllowProfileCreation": 4133 if value != nil { 4134 jtv, ok := value.(bool) 4135 if !ok { 4136 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value) 4137 } 4138 sv.AllowProfileCreation = jtv 4139 } 4140 4141 case "CreatedAt": 4142 if value != nil { 4143 jtv, ok := value.(json.Number) 4144 if !ok { 4145 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 4146 } 4147 f64, err := jtv.Float64() 4148 if err != nil { 4149 return err 4150 } 4151 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4152 } 4153 4154 case "Description": 4155 if value != nil { 4156 jtv, ok := value.(string) 4157 if !ok { 4158 return fmt.Errorf("expected text to be of type string, got %T instead", value) 4159 } 4160 sv.Description = ptr.String(jtv) 4161 } 4162 4163 case "EncryptionKey": 4164 if value != nil { 4165 jtv, ok := value.(string) 4166 if !ok { 4167 return fmt.Errorf("expected encryptionKey to be of type string, got %T instead", value) 4168 } 4169 sv.EncryptionKey = ptr.String(jtv) 4170 } 4171 4172 case "ExpirationDays": 4173 if value != nil { 4174 jtv, ok := value.(json.Number) 4175 if !ok { 4176 return fmt.Errorf("expected expirationDaysInteger to be json.Number, got %T instead", value) 4177 } 4178 i64, err := jtv.Int64() 4179 if err != nil { 4180 return err 4181 } 4182 sv.ExpirationDays = ptr.Int32(int32(i64)) 4183 } 4184 4185 case "Fields": 4186 if err := awsRestjson1_deserializeDocumentFieldMap(&sv.Fields, value); err != nil { 4187 return err 4188 } 4189 4190 case "Keys": 4191 if err := awsRestjson1_deserializeDocumentKeyMap(&sv.Keys, value); err != nil { 4192 return err 4193 } 4194 4195 case "LastUpdatedAt": 4196 if value != nil { 4197 jtv, ok := value.(json.Number) 4198 if !ok { 4199 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 4200 } 4201 f64, err := jtv.Float64() 4202 if err != nil { 4203 return err 4204 } 4205 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4206 } 4207 4208 case "ObjectTypeName": 4209 if value != nil { 4210 jtv, ok := value.(string) 4211 if !ok { 4212 return fmt.Errorf("expected typeName to be of type string, got %T instead", value) 4213 } 4214 sv.ObjectTypeName = ptr.String(jtv) 4215 } 4216 4217 case "Tags": 4218 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 4219 return err 4220 } 4221 4222 case "TemplateId": 4223 if value != nil { 4224 jtv, ok := value.(string) 4225 if !ok { 4226 return fmt.Errorf("expected name to be of type string, got %T instead", value) 4227 } 4228 sv.TemplateId = ptr.String(jtv) 4229 } 4230 4231 default: 4232 _, _ = key, value 4233 4234 } 4235 } 4236 *v = sv 4237 return nil 4238} 4239 4240type awsRestjson1_deserializeOpSearchProfiles struct { 4241} 4242 4243func (*awsRestjson1_deserializeOpSearchProfiles) ID() string { 4244 return "OperationDeserializer" 4245} 4246 4247func (m *awsRestjson1_deserializeOpSearchProfiles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4248 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4249) { 4250 out, metadata, err = next.HandleDeserialize(ctx, in) 4251 if err != nil { 4252 return out, metadata, err 4253 } 4254 4255 response, ok := out.RawResponse.(*smithyhttp.Response) 4256 if !ok { 4257 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4258 } 4259 4260 if response.StatusCode < 200 || response.StatusCode >= 300 { 4261 return out, metadata, awsRestjson1_deserializeOpErrorSearchProfiles(response, &metadata) 4262 } 4263 output := &SearchProfilesOutput{} 4264 out.Result = output 4265 4266 var buff [1024]byte 4267 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4268 4269 body := io.TeeReader(response.Body, ringBuffer) 4270 4271 decoder := json.NewDecoder(body) 4272 decoder.UseNumber() 4273 var shape interface{} 4274 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4275 var snapshot bytes.Buffer 4276 io.Copy(&snapshot, ringBuffer) 4277 err = &smithy.DeserializationError{ 4278 Err: fmt.Errorf("failed to decode response body, %w", err), 4279 Snapshot: snapshot.Bytes(), 4280 } 4281 return out, metadata, err 4282 } 4283 4284 err = awsRestjson1_deserializeOpDocumentSearchProfilesOutput(&output, shape) 4285 if err != nil { 4286 var snapshot bytes.Buffer 4287 io.Copy(&snapshot, ringBuffer) 4288 return out, metadata, &smithy.DeserializationError{ 4289 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4290 Snapshot: snapshot.Bytes(), 4291 } 4292 } 4293 4294 return out, metadata, err 4295} 4296 4297func awsRestjson1_deserializeOpErrorSearchProfiles(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4298 var errorBuffer bytes.Buffer 4299 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4300 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4301 } 4302 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4303 4304 errorCode := "UnknownError" 4305 errorMessage := errorCode 4306 4307 code := response.Header.Get("X-Amzn-ErrorType") 4308 if len(code) != 0 { 4309 errorCode = restjson.SanitizeErrorCode(code) 4310 } 4311 4312 var buff [1024]byte 4313 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4314 4315 body := io.TeeReader(errorBody, ringBuffer) 4316 decoder := json.NewDecoder(body) 4317 decoder.UseNumber() 4318 code, message, err := restjson.GetErrorInfo(decoder) 4319 if err != nil { 4320 var snapshot bytes.Buffer 4321 io.Copy(&snapshot, ringBuffer) 4322 err = &smithy.DeserializationError{ 4323 Err: fmt.Errorf("failed to decode response body, %w", err), 4324 Snapshot: snapshot.Bytes(), 4325 } 4326 return err 4327 } 4328 4329 errorBody.Seek(0, io.SeekStart) 4330 if len(code) != 0 { 4331 errorCode = restjson.SanitizeErrorCode(code) 4332 } 4333 if len(message) != 0 { 4334 errorMessage = message 4335 } 4336 4337 switch { 4338 case strings.EqualFold("AccessDeniedException", errorCode): 4339 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4340 4341 case strings.EqualFold("BadRequestException", errorCode): 4342 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4343 4344 case strings.EqualFold("InternalServerException", errorCode): 4345 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4346 4347 case strings.EqualFold("ResourceNotFoundException", errorCode): 4348 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4349 4350 case strings.EqualFold("ThrottlingException", errorCode): 4351 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4352 4353 default: 4354 genericError := &smithy.GenericAPIError{ 4355 Code: errorCode, 4356 Message: errorMessage, 4357 } 4358 return genericError 4359 4360 } 4361} 4362 4363func awsRestjson1_deserializeOpDocumentSearchProfilesOutput(v **SearchProfilesOutput, value interface{}) error { 4364 if v == nil { 4365 return fmt.Errorf("unexpected nil of type %T", v) 4366 } 4367 if value == nil { 4368 return nil 4369 } 4370 4371 shape, ok := value.(map[string]interface{}) 4372 if !ok { 4373 return fmt.Errorf("unexpected JSON type %v", value) 4374 } 4375 4376 var sv *SearchProfilesOutput 4377 if *v == nil { 4378 sv = &SearchProfilesOutput{} 4379 } else { 4380 sv = *v 4381 } 4382 4383 for key, value := range shape { 4384 switch key { 4385 case "Items": 4386 if err := awsRestjson1_deserializeDocumentProfileList(&sv.Items, value); err != nil { 4387 return err 4388 } 4389 4390 case "NextToken": 4391 if value != nil { 4392 jtv, ok := value.(string) 4393 if !ok { 4394 return fmt.Errorf("expected token to be of type string, got %T instead", value) 4395 } 4396 sv.NextToken = ptr.String(jtv) 4397 } 4398 4399 default: 4400 _, _ = key, value 4401 4402 } 4403 } 4404 *v = sv 4405 return nil 4406} 4407 4408type awsRestjson1_deserializeOpTagResource struct { 4409} 4410 4411func (*awsRestjson1_deserializeOpTagResource) ID() string { 4412 return "OperationDeserializer" 4413} 4414 4415func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4416 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4417) { 4418 out, metadata, err = next.HandleDeserialize(ctx, in) 4419 if err != nil { 4420 return out, metadata, err 4421 } 4422 4423 response, ok := out.RawResponse.(*smithyhttp.Response) 4424 if !ok { 4425 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4426 } 4427 4428 if response.StatusCode < 200 || response.StatusCode >= 300 { 4429 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 4430 } 4431 output := &TagResourceOutput{} 4432 out.Result = output 4433 4434 return out, metadata, err 4435} 4436 4437func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4438 var errorBuffer bytes.Buffer 4439 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4440 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4441 } 4442 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4443 4444 errorCode := "UnknownError" 4445 errorMessage := errorCode 4446 4447 code := response.Header.Get("X-Amzn-ErrorType") 4448 if len(code) != 0 { 4449 errorCode = restjson.SanitizeErrorCode(code) 4450 } 4451 4452 var buff [1024]byte 4453 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4454 4455 body := io.TeeReader(errorBody, ringBuffer) 4456 decoder := json.NewDecoder(body) 4457 decoder.UseNumber() 4458 code, message, err := restjson.GetErrorInfo(decoder) 4459 if err != nil { 4460 var snapshot bytes.Buffer 4461 io.Copy(&snapshot, ringBuffer) 4462 err = &smithy.DeserializationError{ 4463 Err: fmt.Errorf("failed to decode response body, %w", err), 4464 Snapshot: snapshot.Bytes(), 4465 } 4466 return err 4467 } 4468 4469 errorBody.Seek(0, io.SeekStart) 4470 if len(code) != 0 { 4471 errorCode = restjson.SanitizeErrorCode(code) 4472 } 4473 if len(message) != 0 { 4474 errorMessage = message 4475 } 4476 4477 switch { 4478 case strings.EqualFold("BadRequestException", errorCode): 4479 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4480 4481 case strings.EqualFold("InternalServerException", errorCode): 4482 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4483 4484 case strings.EqualFold("ResourceNotFoundException", errorCode): 4485 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4486 4487 default: 4488 genericError := &smithy.GenericAPIError{ 4489 Code: errorCode, 4490 Message: errorMessage, 4491 } 4492 return genericError 4493 4494 } 4495} 4496 4497type awsRestjson1_deserializeOpUntagResource struct { 4498} 4499 4500func (*awsRestjson1_deserializeOpUntagResource) ID() string { 4501 return "OperationDeserializer" 4502} 4503 4504func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4505 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4506) { 4507 out, metadata, err = next.HandleDeserialize(ctx, in) 4508 if err != nil { 4509 return out, metadata, err 4510 } 4511 4512 response, ok := out.RawResponse.(*smithyhttp.Response) 4513 if !ok { 4514 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4515 } 4516 4517 if response.StatusCode < 200 || response.StatusCode >= 300 { 4518 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 4519 } 4520 output := &UntagResourceOutput{} 4521 out.Result = output 4522 4523 return out, metadata, err 4524} 4525 4526func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4527 var errorBuffer bytes.Buffer 4528 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4529 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4530 } 4531 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4532 4533 errorCode := "UnknownError" 4534 errorMessage := errorCode 4535 4536 code := response.Header.Get("X-Amzn-ErrorType") 4537 if len(code) != 0 { 4538 errorCode = restjson.SanitizeErrorCode(code) 4539 } 4540 4541 var buff [1024]byte 4542 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4543 4544 body := io.TeeReader(errorBody, ringBuffer) 4545 decoder := json.NewDecoder(body) 4546 decoder.UseNumber() 4547 code, message, err := restjson.GetErrorInfo(decoder) 4548 if err != nil { 4549 var snapshot bytes.Buffer 4550 io.Copy(&snapshot, ringBuffer) 4551 err = &smithy.DeserializationError{ 4552 Err: fmt.Errorf("failed to decode response body, %w", err), 4553 Snapshot: snapshot.Bytes(), 4554 } 4555 return err 4556 } 4557 4558 errorBody.Seek(0, io.SeekStart) 4559 if len(code) != 0 { 4560 errorCode = restjson.SanitizeErrorCode(code) 4561 } 4562 if len(message) != 0 { 4563 errorMessage = message 4564 } 4565 4566 switch { 4567 case strings.EqualFold("BadRequestException", errorCode): 4568 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4569 4570 case strings.EqualFold("InternalServerException", errorCode): 4571 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4572 4573 case strings.EqualFold("ResourceNotFoundException", errorCode): 4574 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4575 4576 default: 4577 genericError := &smithy.GenericAPIError{ 4578 Code: errorCode, 4579 Message: errorMessage, 4580 } 4581 return genericError 4582 4583 } 4584} 4585 4586type awsRestjson1_deserializeOpUpdateDomain struct { 4587} 4588 4589func (*awsRestjson1_deserializeOpUpdateDomain) ID() string { 4590 return "OperationDeserializer" 4591} 4592 4593func (m *awsRestjson1_deserializeOpUpdateDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4594 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4595) { 4596 out, metadata, err = next.HandleDeserialize(ctx, in) 4597 if err != nil { 4598 return out, metadata, err 4599 } 4600 4601 response, ok := out.RawResponse.(*smithyhttp.Response) 4602 if !ok { 4603 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4604 } 4605 4606 if response.StatusCode < 200 || response.StatusCode >= 300 { 4607 return out, metadata, awsRestjson1_deserializeOpErrorUpdateDomain(response, &metadata) 4608 } 4609 output := &UpdateDomainOutput{} 4610 out.Result = output 4611 4612 var buff [1024]byte 4613 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4614 4615 body := io.TeeReader(response.Body, ringBuffer) 4616 4617 decoder := json.NewDecoder(body) 4618 decoder.UseNumber() 4619 var shape interface{} 4620 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4621 var snapshot bytes.Buffer 4622 io.Copy(&snapshot, ringBuffer) 4623 err = &smithy.DeserializationError{ 4624 Err: fmt.Errorf("failed to decode response body, %w", err), 4625 Snapshot: snapshot.Bytes(), 4626 } 4627 return out, metadata, err 4628 } 4629 4630 err = awsRestjson1_deserializeOpDocumentUpdateDomainOutput(&output, shape) 4631 if err != nil { 4632 var snapshot bytes.Buffer 4633 io.Copy(&snapshot, ringBuffer) 4634 return out, metadata, &smithy.DeserializationError{ 4635 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4636 Snapshot: snapshot.Bytes(), 4637 } 4638 } 4639 4640 return out, metadata, err 4641} 4642 4643func awsRestjson1_deserializeOpErrorUpdateDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4644 var errorBuffer bytes.Buffer 4645 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4646 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4647 } 4648 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4649 4650 errorCode := "UnknownError" 4651 errorMessage := errorCode 4652 4653 code := response.Header.Get("X-Amzn-ErrorType") 4654 if len(code) != 0 { 4655 errorCode = restjson.SanitizeErrorCode(code) 4656 } 4657 4658 var buff [1024]byte 4659 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4660 4661 body := io.TeeReader(errorBody, ringBuffer) 4662 decoder := json.NewDecoder(body) 4663 decoder.UseNumber() 4664 code, message, err := restjson.GetErrorInfo(decoder) 4665 if err != nil { 4666 var snapshot bytes.Buffer 4667 io.Copy(&snapshot, ringBuffer) 4668 err = &smithy.DeserializationError{ 4669 Err: fmt.Errorf("failed to decode response body, %w", err), 4670 Snapshot: snapshot.Bytes(), 4671 } 4672 return err 4673 } 4674 4675 errorBody.Seek(0, io.SeekStart) 4676 if len(code) != 0 { 4677 errorCode = restjson.SanitizeErrorCode(code) 4678 } 4679 if len(message) != 0 { 4680 errorMessage = message 4681 } 4682 4683 switch { 4684 case strings.EqualFold("AccessDeniedException", errorCode): 4685 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4686 4687 case strings.EqualFold("BadRequestException", errorCode): 4688 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4689 4690 case strings.EqualFold("InternalServerException", errorCode): 4691 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4692 4693 case strings.EqualFold("ResourceNotFoundException", errorCode): 4694 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4695 4696 case strings.EqualFold("ThrottlingException", errorCode): 4697 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4698 4699 default: 4700 genericError := &smithy.GenericAPIError{ 4701 Code: errorCode, 4702 Message: errorMessage, 4703 } 4704 return genericError 4705 4706 } 4707} 4708 4709func awsRestjson1_deserializeOpDocumentUpdateDomainOutput(v **UpdateDomainOutput, value interface{}) error { 4710 if v == nil { 4711 return fmt.Errorf("unexpected nil of type %T", v) 4712 } 4713 if value == nil { 4714 return nil 4715 } 4716 4717 shape, ok := value.(map[string]interface{}) 4718 if !ok { 4719 return fmt.Errorf("unexpected JSON type %v", value) 4720 } 4721 4722 var sv *UpdateDomainOutput 4723 if *v == nil { 4724 sv = &UpdateDomainOutput{} 4725 } else { 4726 sv = *v 4727 } 4728 4729 for key, value := range shape { 4730 switch key { 4731 case "CreatedAt": 4732 if value != nil { 4733 jtv, ok := value.(json.Number) 4734 if !ok { 4735 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 4736 } 4737 f64, err := jtv.Float64() 4738 if err != nil { 4739 return err 4740 } 4741 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4742 } 4743 4744 case "DeadLetterQueueUrl": 4745 if value != nil { 4746 jtv, ok := value.(string) 4747 if !ok { 4748 return fmt.Errorf("expected sqsQueueUrl to be of type string, got %T instead", value) 4749 } 4750 sv.DeadLetterQueueUrl = ptr.String(jtv) 4751 } 4752 4753 case "DefaultEncryptionKey": 4754 if value != nil { 4755 jtv, ok := value.(string) 4756 if !ok { 4757 return fmt.Errorf("expected encryptionKey to be of type string, got %T instead", value) 4758 } 4759 sv.DefaultEncryptionKey = ptr.String(jtv) 4760 } 4761 4762 case "DefaultExpirationDays": 4763 if value != nil { 4764 jtv, ok := value.(json.Number) 4765 if !ok { 4766 return fmt.Errorf("expected expirationDaysInteger to be json.Number, got %T instead", value) 4767 } 4768 i64, err := jtv.Int64() 4769 if err != nil { 4770 return err 4771 } 4772 sv.DefaultExpirationDays = ptr.Int32(int32(i64)) 4773 } 4774 4775 case "DomainName": 4776 if value != nil { 4777 jtv, ok := value.(string) 4778 if !ok { 4779 return fmt.Errorf("expected name to be of type string, got %T instead", value) 4780 } 4781 sv.DomainName = ptr.String(jtv) 4782 } 4783 4784 case "LastUpdatedAt": 4785 if value != nil { 4786 jtv, ok := value.(json.Number) 4787 if !ok { 4788 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 4789 } 4790 f64, err := jtv.Float64() 4791 if err != nil { 4792 return err 4793 } 4794 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4795 } 4796 4797 case "Tags": 4798 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 4799 return err 4800 } 4801 4802 default: 4803 _, _ = key, value 4804 4805 } 4806 } 4807 *v = sv 4808 return nil 4809} 4810 4811type awsRestjson1_deserializeOpUpdateProfile struct { 4812} 4813 4814func (*awsRestjson1_deserializeOpUpdateProfile) ID() string { 4815 return "OperationDeserializer" 4816} 4817 4818func (m *awsRestjson1_deserializeOpUpdateProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4819 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4820) { 4821 out, metadata, err = next.HandleDeserialize(ctx, in) 4822 if err != nil { 4823 return out, metadata, err 4824 } 4825 4826 response, ok := out.RawResponse.(*smithyhttp.Response) 4827 if !ok { 4828 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4829 } 4830 4831 if response.StatusCode < 200 || response.StatusCode >= 300 { 4832 return out, metadata, awsRestjson1_deserializeOpErrorUpdateProfile(response, &metadata) 4833 } 4834 output := &UpdateProfileOutput{} 4835 out.Result = output 4836 4837 var buff [1024]byte 4838 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4839 4840 body := io.TeeReader(response.Body, ringBuffer) 4841 4842 decoder := json.NewDecoder(body) 4843 decoder.UseNumber() 4844 var shape interface{} 4845 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4846 var snapshot bytes.Buffer 4847 io.Copy(&snapshot, ringBuffer) 4848 err = &smithy.DeserializationError{ 4849 Err: fmt.Errorf("failed to decode response body, %w", err), 4850 Snapshot: snapshot.Bytes(), 4851 } 4852 return out, metadata, err 4853 } 4854 4855 err = awsRestjson1_deserializeOpDocumentUpdateProfileOutput(&output, shape) 4856 if err != nil { 4857 var snapshot bytes.Buffer 4858 io.Copy(&snapshot, ringBuffer) 4859 return out, metadata, &smithy.DeserializationError{ 4860 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4861 Snapshot: snapshot.Bytes(), 4862 } 4863 } 4864 4865 return out, metadata, err 4866} 4867 4868func awsRestjson1_deserializeOpErrorUpdateProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4869 var errorBuffer bytes.Buffer 4870 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4871 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4872 } 4873 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4874 4875 errorCode := "UnknownError" 4876 errorMessage := errorCode 4877 4878 code := response.Header.Get("X-Amzn-ErrorType") 4879 if len(code) != 0 { 4880 errorCode = restjson.SanitizeErrorCode(code) 4881 } 4882 4883 var buff [1024]byte 4884 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4885 4886 body := io.TeeReader(errorBody, ringBuffer) 4887 decoder := json.NewDecoder(body) 4888 decoder.UseNumber() 4889 code, message, err := restjson.GetErrorInfo(decoder) 4890 if err != nil { 4891 var snapshot bytes.Buffer 4892 io.Copy(&snapshot, ringBuffer) 4893 err = &smithy.DeserializationError{ 4894 Err: fmt.Errorf("failed to decode response body, %w", err), 4895 Snapshot: snapshot.Bytes(), 4896 } 4897 return err 4898 } 4899 4900 errorBody.Seek(0, io.SeekStart) 4901 if len(code) != 0 { 4902 errorCode = restjson.SanitizeErrorCode(code) 4903 } 4904 if len(message) != 0 { 4905 errorMessage = message 4906 } 4907 4908 switch { 4909 case strings.EqualFold("AccessDeniedException", errorCode): 4910 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4911 4912 case strings.EqualFold("BadRequestException", errorCode): 4913 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4914 4915 case strings.EqualFold("InternalServerException", errorCode): 4916 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 4917 4918 case strings.EqualFold("ResourceNotFoundException", errorCode): 4919 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4920 4921 case strings.EqualFold("ThrottlingException", errorCode): 4922 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 4923 4924 default: 4925 genericError := &smithy.GenericAPIError{ 4926 Code: errorCode, 4927 Message: errorMessage, 4928 } 4929 return genericError 4930 4931 } 4932} 4933 4934func awsRestjson1_deserializeOpDocumentUpdateProfileOutput(v **UpdateProfileOutput, value interface{}) error { 4935 if v == nil { 4936 return fmt.Errorf("unexpected nil of type %T", v) 4937 } 4938 if value == nil { 4939 return nil 4940 } 4941 4942 shape, ok := value.(map[string]interface{}) 4943 if !ok { 4944 return fmt.Errorf("unexpected JSON type %v", value) 4945 } 4946 4947 var sv *UpdateProfileOutput 4948 if *v == nil { 4949 sv = &UpdateProfileOutput{} 4950 } else { 4951 sv = *v 4952 } 4953 4954 for key, value := range shape { 4955 switch key { 4956 case "ProfileId": 4957 if value != nil { 4958 jtv, ok := value.(string) 4959 if !ok { 4960 return fmt.Errorf("expected uuid to be of type string, got %T instead", value) 4961 } 4962 sv.ProfileId = ptr.String(jtv) 4963 } 4964 4965 default: 4966 _, _ = key, value 4967 4968 } 4969 } 4970 *v = sv 4971 return nil 4972} 4973 4974func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4975 output := &types.AccessDeniedException{} 4976 var buff [1024]byte 4977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4978 4979 body := io.TeeReader(errorBody, ringBuffer) 4980 decoder := json.NewDecoder(body) 4981 decoder.UseNumber() 4982 var shape interface{} 4983 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4984 var snapshot bytes.Buffer 4985 io.Copy(&snapshot, ringBuffer) 4986 err = &smithy.DeserializationError{ 4987 Err: fmt.Errorf("failed to decode response body, %w", err), 4988 Snapshot: snapshot.Bytes(), 4989 } 4990 return err 4991 } 4992 4993 err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape) 4994 4995 if err != nil { 4996 var snapshot bytes.Buffer 4997 io.Copy(&snapshot, ringBuffer) 4998 err = &smithy.DeserializationError{ 4999 Err: fmt.Errorf("failed to decode response body, %w", err), 5000 Snapshot: snapshot.Bytes(), 5001 } 5002 return err 5003 } 5004 5005 errorBody.Seek(0, io.SeekStart) 5006 5007 return output 5008} 5009 5010func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5011 output := &types.BadRequestException{} 5012 var buff [1024]byte 5013 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5014 5015 body := io.TeeReader(errorBody, ringBuffer) 5016 decoder := json.NewDecoder(body) 5017 decoder.UseNumber() 5018 var shape interface{} 5019 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5020 var snapshot bytes.Buffer 5021 io.Copy(&snapshot, ringBuffer) 5022 err = &smithy.DeserializationError{ 5023 Err: fmt.Errorf("failed to decode response body, %w", err), 5024 Snapshot: snapshot.Bytes(), 5025 } 5026 return err 5027 } 5028 5029 err := awsRestjson1_deserializeDocumentBadRequestException(&output, shape) 5030 5031 if err != nil { 5032 var snapshot bytes.Buffer 5033 io.Copy(&snapshot, ringBuffer) 5034 err = &smithy.DeserializationError{ 5035 Err: fmt.Errorf("failed to decode response body, %w", err), 5036 Snapshot: snapshot.Bytes(), 5037 } 5038 return err 5039 } 5040 5041 errorBody.Seek(0, io.SeekStart) 5042 5043 return output 5044} 5045 5046func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5047 output := &types.InternalServerException{} 5048 var buff [1024]byte 5049 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5050 5051 body := io.TeeReader(errorBody, ringBuffer) 5052 decoder := json.NewDecoder(body) 5053 decoder.UseNumber() 5054 var shape interface{} 5055 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5056 var snapshot bytes.Buffer 5057 io.Copy(&snapshot, ringBuffer) 5058 err = &smithy.DeserializationError{ 5059 Err: fmt.Errorf("failed to decode response body, %w", err), 5060 Snapshot: snapshot.Bytes(), 5061 } 5062 return err 5063 } 5064 5065 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape) 5066 5067 if err != nil { 5068 var snapshot bytes.Buffer 5069 io.Copy(&snapshot, ringBuffer) 5070 err = &smithy.DeserializationError{ 5071 Err: fmt.Errorf("failed to decode response body, %w", err), 5072 Snapshot: snapshot.Bytes(), 5073 } 5074 return err 5075 } 5076 5077 errorBody.Seek(0, io.SeekStart) 5078 5079 return output 5080} 5081 5082func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5083 output := &types.ResourceNotFoundException{} 5084 var buff [1024]byte 5085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5086 5087 body := io.TeeReader(errorBody, ringBuffer) 5088 decoder := json.NewDecoder(body) 5089 decoder.UseNumber() 5090 var shape interface{} 5091 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5092 var snapshot bytes.Buffer 5093 io.Copy(&snapshot, ringBuffer) 5094 err = &smithy.DeserializationError{ 5095 Err: fmt.Errorf("failed to decode response body, %w", err), 5096 Snapshot: snapshot.Bytes(), 5097 } 5098 return err 5099 } 5100 5101 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 5102 5103 if err != nil { 5104 var snapshot bytes.Buffer 5105 io.Copy(&snapshot, ringBuffer) 5106 err = &smithy.DeserializationError{ 5107 Err: fmt.Errorf("failed to decode response body, %w", err), 5108 Snapshot: snapshot.Bytes(), 5109 } 5110 return err 5111 } 5112 5113 errorBody.Seek(0, io.SeekStart) 5114 5115 return output 5116} 5117 5118func awsRestjson1_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5119 output := &types.ThrottlingException{} 5120 var buff [1024]byte 5121 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5122 5123 body := io.TeeReader(errorBody, ringBuffer) 5124 decoder := json.NewDecoder(body) 5125 decoder.UseNumber() 5126 var shape interface{} 5127 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5128 var snapshot bytes.Buffer 5129 io.Copy(&snapshot, ringBuffer) 5130 err = &smithy.DeserializationError{ 5131 Err: fmt.Errorf("failed to decode response body, %w", err), 5132 Snapshot: snapshot.Bytes(), 5133 } 5134 return err 5135 } 5136 5137 err := awsRestjson1_deserializeDocumentThrottlingException(&output, shape) 5138 5139 if err != nil { 5140 var snapshot bytes.Buffer 5141 io.Copy(&snapshot, ringBuffer) 5142 err = &smithy.DeserializationError{ 5143 Err: fmt.Errorf("failed to decode response body, %w", err), 5144 Snapshot: snapshot.Bytes(), 5145 } 5146 return err 5147 } 5148 5149 errorBody.Seek(0, io.SeekStart) 5150 5151 return output 5152} 5153 5154func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 5155 if v == nil { 5156 return fmt.Errorf("unexpected nil of type %T", v) 5157 } 5158 if value == nil { 5159 return nil 5160 } 5161 5162 shape, ok := value.(map[string]interface{}) 5163 if !ok { 5164 return fmt.Errorf("unexpected JSON type %v", value) 5165 } 5166 5167 var sv *types.AccessDeniedException 5168 if *v == nil { 5169 sv = &types.AccessDeniedException{} 5170 } else { 5171 sv = *v 5172 } 5173 5174 for key, value := range shape { 5175 switch key { 5176 case "Message": 5177 if value != nil { 5178 jtv, ok := value.(string) 5179 if !ok { 5180 return fmt.Errorf("expected message to be of type string, got %T instead", value) 5181 } 5182 sv.Message = ptr.String(jtv) 5183 } 5184 5185 default: 5186 _, _ = key, value 5187 5188 } 5189 } 5190 *v = sv 5191 return nil 5192} 5193 5194func awsRestjson1_deserializeDocumentAddress(v **types.Address, value interface{}) error { 5195 if v == nil { 5196 return fmt.Errorf("unexpected nil of type %T", v) 5197 } 5198 if value == nil { 5199 return nil 5200 } 5201 5202 shape, ok := value.(map[string]interface{}) 5203 if !ok { 5204 return fmt.Errorf("unexpected JSON type %v", value) 5205 } 5206 5207 var sv *types.Address 5208 if *v == nil { 5209 sv = &types.Address{} 5210 } else { 5211 sv = *v 5212 } 5213 5214 for key, value := range shape { 5215 switch key { 5216 case "Address1": 5217 if value != nil { 5218 jtv, ok := value.(string) 5219 if !ok { 5220 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5221 } 5222 sv.Address1 = ptr.String(jtv) 5223 } 5224 5225 case "Address2": 5226 if value != nil { 5227 jtv, ok := value.(string) 5228 if !ok { 5229 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5230 } 5231 sv.Address2 = ptr.String(jtv) 5232 } 5233 5234 case "Address3": 5235 if value != nil { 5236 jtv, ok := value.(string) 5237 if !ok { 5238 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5239 } 5240 sv.Address3 = ptr.String(jtv) 5241 } 5242 5243 case "Address4": 5244 if value != nil { 5245 jtv, ok := value.(string) 5246 if !ok { 5247 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5248 } 5249 sv.Address4 = ptr.String(jtv) 5250 } 5251 5252 case "City": 5253 if value != nil { 5254 jtv, ok := value.(string) 5255 if !ok { 5256 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5257 } 5258 sv.City = ptr.String(jtv) 5259 } 5260 5261 case "Country": 5262 if value != nil { 5263 jtv, ok := value.(string) 5264 if !ok { 5265 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5266 } 5267 sv.Country = ptr.String(jtv) 5268 } 5269 5270 case "County": 5271 if value != nil { 5272 jtv, ok := value.(string) 5273 if !ok { 5274 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5275 } 5276 sv.County = ptr.String(jtv) 5277 } 5278 5279 case "PostalCode": 5280 if value != nil { 5281 jtv, ok := value.(string) 5282 if !ok { 5283 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5284 } 5285 sv.PostalCode = ptr.String(jtv) 5286 } 5287 5288 case "Province": 5289 if value != nil { 5290 jtv, ok := value.(string) 5291 if !ok { 5292 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5293 } 5294 sv.Province = ptr.String(jtv) 5295 } 5296 5297 case "State": 5298 if value != nil { 5299 jtv, ok := value.(string) 5300 if !ok { 5301 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5302 } 5303 sv.State = ptr.String(jtv) 5304 } 5305 5306 default: 5307 _, _ = key, value 5308 5309 } 5310 } 5311 *v = sv 5312 return nil 5313} 5314 5315func awsRestjson1_deserializeDocumentAttributes(v *map[string]string, value interface{}) error { 5316 if v == nil { 5317 return fmt.Errorf("unexpected nil of type %T", v) 5318 } 5319 if value == nil { 5320 return nil 5321 } 5322 5323 shape, ok := value.(map[string]interface{}) 5324 if !ok { 5325 return fmt.Errorf("unexpected JSON type %v", value) 5326 } 5327 5328 var mv map[string]string 5329 if *v == nil { 5330 mv = map[string]string{} 5331 } else { 5332 mv = *v 5333 } 5334 5335 for key, value := range shape { 5336 var parsedVal string 5337 if value != nil { 5338 jtv, ok := value.(string) 5339 if !ok { 5340 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5341 } 5342 parsedVal = jtv 5343 } 5344 mv[key] = parsedVal 5345 5346 } 5347 *v = mv 5348 return nil 5349} 5350 5351func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 5352 if v == nil { 5353 return fmt.Errorf("unexpected nil of type %T", v) 5354 } 5355 if value == nil { 5356 return nil 5357 } 5358 5359 shape, ok := value.(map[string]interface{}) 5360 if !ok { 5361 return fmt.Errorf("unexpected JSON type %v", value) 5362 } 5363 5364 var sv *types.BadRequestException 5365 if *v == nil { 5366 sv = &types.BadRequestException{} 5367 } else { 5368 sv = *v 5369 } 5370 5371 for key, value := range shape { 5372 switch key { 5373 case "Message": 5374 if value != nil { 5375 jtv, ok := value.(string) 5376 if !ok { 5377 return fmt.Errorf("expected message to be of type string, got %T instead", value) 5378 } 5379 sv.Message = ptr.String(jtv) 5380 } 5381 5382 default: 5383 _, _ = key, value 5384 5385 } 5386 } 5387 *v = sv 5388 return nil 5389} 5390 5391func awsRestjson1_deserializeDocumentDomainList(v *[]types.ListDomainItem, value interface{}) error { 5392 if v == nil { 5393 return fmt.Errorf("unexpected nil of type %T", v) 5394 } 5395 if value == nil { 5396 return nil 5397 } 5398 5399 shape, ok := value.([]interface{}) 5400 if !ok { 5401 return fmt.Errorf("unexpected JSON type %v", value) 5402 } 5403 5404 var cv []types.ListDomainItem 5405 if *v == nil { 5406 cv = []types.ListDomainItem{} 5407 } else { 5408 cv = *v 5409 } 5410 5411 for _, value := range shape { 5412 var col types.ListDomainItem 5413 destAddr := &col 5414 if err := awsRestjson1_deserializeDocumentListDomainItem(&destAddr, value); err != nil { 5415 return err 5416 } 5417 col = *destAddr 5418 cv = append(cv, col) 5419 5420 } 5421 *v = cv 5422 return nil 5423} 5424 5425func awsRestjson1_deserializeDocumentDomainStats(v **types.DomainStats, value interface{}) error { 5426 if v == nil { 5427 return fmt.Errorf("unexpected nil of type %T", v) 5428 } 5429 if value == nil { 5430 return nil 5431 } 5432 5433 shape, ok := value.(map[string]interface{}) 5434 if !ok { 5435 return fmt.Errorf("unexpected JSON type %v", value) 5436 } 5437 5438 var sv *types.DomainStats 5439 if *v == nil { 5440 sv = &types.DomainStats{} 5441 } else { 5442 sv = *v 5443 } 5444 5445 for key, value := range shape { 5446 switch key { 5447 case "MeteringProfileCount": 5448 if value != nil { 5449 jtv, ok := value.(json.Number) 5450 if !ok { 5451 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 5452 } 5453 i64, err := jtv.Int64() 5454 if err != nil { 5455 return err 5456 } 5457 sv.MeteringProfileCount = i64 5458 } 5459 5460 case "ObjectCount": 5461 if value != nil { 5462 jtv, ok := value.(json.Number) 5463 if !ok { 5464 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 5465 } 5466 i64, err := jtv.Int64() 5467 if err != nil { 5468 return err 5469 } 5470 sv.ObjectCount = i64 5471 } 5472 5473 case "ProfileCount": 5474 if value != nil { 5475 jtv, ok := value.(json.Number) 5476 if !ok { 5477 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 5478 } 5479 i64, err := jtv.Int64() 5480 if err != nil { 5481 return err 5482 } 5483 sv.ProfileCount = i64 5484 } 5485 5486 case "TotalSize": 5487 if value != nil { 5488 jtv, ok := value.(json.Number) 5489 if !ok { 5490 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 5491 } 5492 i64, err := jtv.Int64() 5493 if err != nil { 5494 return err 5495 } 5496 sv.TotalSize = i64 5497 } 5498 5499 default: 5500 _, _ = key, value 5501 5502 } 5503 } 5504 *v = sv 5505 return nil 5506} 5507 5508func awsRestjson1_deserializeDocumentFieldMap(v *map[string]types.ObjectTypeField, value interface{}) error { 5509 if v == nil { 5510 return fmt.Errorf("unexpected nil of type %T", v) 5511 } 5512 if value == nil { 5513 return nil 5514 } 5515 5516 shape, ok := value.(map[string]interface{}) 5517 if !ok { 5518 return fmt.Errorf("unexpected JSON type %v", value) 5519 } 5520 5521 var mv map[string]types.ObjectTypeField 5522 if *v == nil { 5523 mv = map[string]types.ObjectTypeField{} 5524 } else { 5525 mv = *v 5526 } 5527 5528 for key, value := range shape { 5529 var parsedVal types.ObjectTypeField 5530 mapVar := parsedVal 5531 destAddr := &mapVar 5532 if err := awsRestjson1_deserializeDocumentObjectTypeField(&destAddr, value); err != nil { 5533 return err 5534 } 5535 parsedVal = *destAddr 5536 mv[key] = parsedVal 5537 5538 } 5539 *v = mv 5540 return nil 5541} 5542 5543func awsRestjson1_deserializeDocumentFieldNameList(v *[]string, value interface{}) error { 5544 if v == nil { 5545 return fmt.Errorf("unexpected nil of type %T", v) 5546 } 5547 if value == nil { 5548 return nil 5549 } 5550 5551 shape, ok := value.([]interface{}) 5552 if !ok { 5553 return fmt.Errorf("unexpected JSON type %v", value) 5554 } 5555 5556 var cv []string 5557 if *v == nil { 5558 cv = []string{} 5559 } else { 5560 cv = *v 5561 } 5562 5563 for _, value := range shape { 5564 var col string 5565 if value != nil { 5566 jtv, ok := value.(string) 5567 if !ok { 5568 return fmt.Errorf("expected name to be of type string, got %T instead", value) 5569 } 5570 col = jtv 5571 } 5572 cv = append(cv, col) 5573 5574 } 5575 *v = cv 5576 return nil 5577} 5578 5579func awsRestjson1_deserializeDocumentIntegrationList(v *[]types.ListIntegrationItem, value interface{}) error { 5580 if v == nil { 5581 return fmt.Errorf("unexpected nil of type %T", v) 5582 } 5583 if value == nil { 5584 return nil 5585 } 5586 5587 shape, ok := value.([]interface{}) 5588 if !ok { 5589 return fmt.Errorf("unexpected JSON type %v", value) 5590 } 5591 5592 var cv []types.ListIntegrationItem 5593 if *v == nil { 5594 cv = []types.ListIntegrationItem{} 5595 } else { 5596 cv = *v 5597 } 5598 5599 for _, value := range shape { 5600 var col types.ListIntegrationItem 5601 destAddr := &col 5602 if err := awsRestjson1_deserializeDocumentListIntegrationItem(&destAddr, value); err != nil { 5603 return err 5604 } 5605 col = *destAddr 5606 cv = append(cv, col) 5607 5608 } 5609 *v = cv 5610 return nil 5611} 5612 5613func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { 5614 if v == nil { 5615 return fmt.Errorf("unexpected nil of type %T", v) 5616 } 5617 if value == nil { 5618 return nil 5619 } 5620 5621 shape, ok := value.(map[string]interface{}) 5622 if !ok { 5623 return fmt.Errorf("unexpected JSON type %v", value) 5624 } 5625 5626 var sv *types.InternalServerException 5627 if *v == nil { 5628 sv = &types.InternalServerException{} 5629 } else { 5630 sv = *v 5631 } 5632 5633 for key, value := range shape { 5634 switch key { 5635 case "Message": 5636 if value != nil { 5637 jtv, ok := value.(string) 5638 if !ok { 5639 return fmt.Errorf("expected message to be of type string, got %T instead", value) 5640 } 5641 sv.Message = ptr.String(jtv) 5642 } 5643 5644 default: 5645 _, _ = key, value 5646 5647 } 5648 } 5649 *v = sv 5650 return nil 5651} 5652 5653func awsRestjson1_deserializeDocumentKeyMap(v *map[string][]types.ObjectTypeKey, value interface{}) error { 5654 if v == nil { 5655 return fmt.Errorf("unexpected nil of type %T", v) 5656 } 5657 if value == nil { 5658 return nil 5659 } 5660 5661 shape, ok := value.(map[string]interface{}) 5662 if !ok { 5663 return fmt.Errorf("unexpected JSON type %v", value) 5664 } 5665 5666 var mv map[string][]types.ObjectTypeKey 5667 if *v == nil { 5668 mv = map[string][]types.ObjectTypeKey{} 5669 } else { 5670 mv = *v 5671 } 5672 5673 for key, value := range shape { 5674 var parsedVal []types.ObjectTypeKey 5675 mapVar := parsedVal 5676 if err := awsRestjson1_deserializeDocumentObjectTypeKeyList(&mapVar, value); err != nil { 5677 return err 5678 } 5679 parsedVal = mapVar 5680 mv[key] = parsedVal 5681 5682 } 5683 *v = mv 5684 return nil 5685} 5686 5687func awsRestjson1_deserializeDocumentListDomainItem(v **types.ListDomainItem, value interface{}) error { 5688 if v == nil { 5689 return fmt.Errorf("unexpected nil of type %T", v) 5690 } 5691 if value == nil { 5692 return nil 5693 } 5694 5695 shape, ok := value.(map[string]interface{}) 5696 if !ok { 5697 return fmt.Errorf("unexpected JSON type %v", value) 5698 } 5699 5700 var sv *types.ListDomainItem 5701 if *v == nil { 5702 sv = &types.ListDomainItem{} 5703 } else { 5704 sv = *v 5705 } 5706 5707 for key, value := range shape { 5708 switch key { 5709 case "CreatedAt": 5710 if value != nil { 5711 jtv, ok := value.(json.Number) 5712 if !ok { 5713 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 5714 } 5715 f64, err := jtv.Float64() 5716 if err != nil { 5717 return err 5718 } 5719 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5720 } 5721 5722 case "DomainName": 5723 if value != nil { 5724 jtv, ok := value.(string) 5725 if !ok { 5726 return fmt.Errorf("expected name to be of type string, got %T instead", value) 5727 } 5728 sv.DomainName = ptr.String(jtv) 5729 } 5730 5731 case "LastUpdatedAt": 5732 if value != nil { 5733 jtv, ok := value.(json.Number) 5734 if !ok { 5735 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 5736 } 5737 f64, err := jtv.Float64() 5738 if err != nil { 5739 return err 5740 } 5741 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5742 } 5743 5744 case "Tags": 5745 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 5746 return err 5747 } 5748 5749 default: 5750 _, _ = key, value 5751 5752 } 5753 } 5754 *v = sv 5755 return nil 5756} 5757 5758func awsRestjson1_deserializeDocumentListIntegrationItem(v **types.ListIntegrationItem, value interface{}) error { 5759 if v == nil { 5760 return fmt.Errorf("unexpected nil of type %T", v) 5761 } 5762 if value == nil { 5763 return nil 5764 } 5765 5766 shape, ok := value.(map[string]interface{}) 5767 if !ok { 5768 return fmt.Errorf("unexpected JSON type %v", value) 5769 } 5770 5771 var sv *types.ListIntegrationItem 5772 if *v == nil { 5773 sv = &types.ListIntegrationItem{} 5774 } else { 5775 sv = *v 5776 } 5777 5778 for key, value := range shape { 5779 switch key { 5780 case "CreatedAt": 5781 if value != nil { 5782 jtv, ok := value.(json.Number) 5783 if !ok { 5784 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 5785 } 5786 f64, err := jtv.Float64() 5787 if err != nil { 5788 return err 5789 } 5790 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5791 } 5792 5793 case "DomainName": 5794 if value != nil { 5795 jtv, ok := value.(string) 5796 if !ok { 5797 return fmt.Errorf("expected name to be of type string, got %T instead", value) 5798 } 5799 sv.DomainName = ptr.String(jtv) 5800 } 5801 5802 case "LastUpdatedAt": 5803 if value != nil { 5804 jtv, ok := value.(json.Number) 5805 if !ok { 5806 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 5807 } 5808 f64, err := jtv.Float64() 5809 if err != nil { 5810 return err 5811 } 5812 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5813 } 5814 5815 case "ObjectTypeName": 5816 if value != nil { 5817 jtv, ok := value.(string) 5818 if !ok { 5819 return fmt.Errorf("expected typeName to be of type string, got %T instead", value) 5820 } 5821 sv.ObjectTypeName = ptr.String(jtv) 5822 } 5823 5824 case "Tags": 5825 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 5826 return err 5827 } 5828 5829 case "Uri": 5830 if value != nil { 5831 jtv, ok := value.(string) 5832 if !ok { 5833 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5834 } 5835 sv.Uri = ptr.String(jtv) 5836 } 5837 5838 default: 5839 _, _ = key, value 5840 5841 } 5842 } 5843 *v = sv 5844 return nil 5845} 5846 5847func awsRestjson1_deserializeDocumentListProfileObjectsItem(v **types.ListProfileObjectsItem, value interface{}) error { 5848 if v == nil { 5849 return fmt.Errorf("unexpected nil of type %T", v) 5850 } 5851 if value == nil { 5852 return nil 5853 } 5854 5855 shape, ok := value.(map[string]interface{}) 5856 if !ok { 5857 return fmt.Errorf("unexpected JSON type %v", value) 5858 } 5859 5860 var sv *types.ListProfileObjectsItem 5861 if *v == nil { 5862 sv = &types.ListProfileObjectsItem{} 5863 } else { 5864 sv = *v 5865 } 5866 5867 for key, value := range shape { 5868 switch key { 5869 case "Object": 5870 if value != nil { 5871 jtv, ok := value.(string) 5872 if !ok { 5873 return fmt.Errorf("expected stringifiedJson to be of type string, got %T instead", value) 5874 } 5875 sv.Object = ptr.String(jtv) 5876 } 5877 5878 case "ObjectTypeName": 5879 if value != nil { 5880 jtv, ok := value.(string) 5881 if !ok { 5882 return fmt.Errorf("expected typeName to be of type string, got %T instead", value) 5883 } 5884 sv.ObjectTypeName = ptr.String(jtv) 5885 } 5886 5887 case "ProfileObjectUniqueKey": 5888 if value != nil { 5889 jtv, ok := value.(string) 5890 if !ok { 5891 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 5892 } 5893 sv.ProfileObjectUniqueKey = ptr.String(jtv) 5894 } 5895 5896 default: 5897 _, _ = key, value 5898 5899 } 5900 } 5901 *v = sv 5902 return nil 5903} 5904 5905func awsRestjson1_deserializeDocumentListProfileObjectTypeItem(v **types.ListProfileObjectTypeItem, value interface{}) error { 5906 if v == nil { 5907 return fmt.Errorf("unexpected nil of type %T", v) 5908 } 5909 if value == nil { 5910 return nil 5911 } 5912 5913 shape, ok := value.(map[string]interface{}) 5914 if !ok { 5915 return fmt.Errorf("unexpected JSON type %v", value) 5916 } 5917 5918 var sv *types.ListProfileObjectTypeItem 5919 if *v == nil { 5920 sv = &types.ListProfileObjectTypeItem{} 5921 } else { 5922 sv = *v 5923 } 5924 5925 for key, value := range shape { 5926 switch key { 5927 case "CreatedAt": 5928 if value != nil { 5929 jtv, ok := value.(json.Number) 5930 if !ok { 5931 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 5932 } 5933 f64, err := jtv.Float64() 5934 if err != nil { 5935 return err 5936 } 5937 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5938 } 5939 5940 case "Description": 5941 if value != nil { 5942 jtv, ok := value.(string) 5943 if !ok { 5944 return fmt.Errorf("expected text to be of type string, got %T instead", value) 5945 } 5946 sv.Description = ptr.String(jtv) 5947 } 5948 5949 case "LastUpdatedAt": 5950 if value != nil { 5951 jtv, ok := value.(json.Number) 5952 if !ok { 5953 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 5954 } 5955 f64, err := jtv.Float64() 5956 if err != nil { 5957 return err 5958 } 5959 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5960 } 5961 5962 case "ObjectTypeName": 5963 if value != nil { 5964 jtv, ok := value.(string) 5965 if !ok { 5966 return fmt.Errorf("expected typeName to be of type string, got %T instead", value) 5967 } 5968 sv.ObjectTypeName = ptr.String(jtv) 5969 } 5970 5971 case "Tags": 5972 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 5973 return err 5974 } 5975 5976 default: 5977 _, _ = key, value 5978 5979 } 5980 } 5981 *v = sv 5982 return nil 5983} 5984 5985func awsRestjson1_deserializeDocumentListProfileObjectTypeTemplateItem(v **types.ListProfileObjectTypeTemplateItem, value interface{}) error { 5986 if v == nil { 5987 return fmt.Errorf("unexpected nil of type %T", v) 5988 } 5989 if value == nil { 5990 return nil 5991 } 5992 5993 shape, ok := value.(map[string]interface{}) 5994 if !ok { 5995 return fmt.Errorf("unexpected JSON type %v", value) 5996 } 5997 5998 var sv *types.ListProfileObjectTypeTemplateItem 5999 if *v == nil { 6000 sv = &types.ListProfileObjectTypeTemplateItem{} 6001 } else { 6002 sv = *v 6003 } 6004 6005 for key, value := range shape { 6006 switch key { 6007 case "SourceName": 6008 if value != nil { 6009 jtv, ok := value.(string) 6010 if !ok { 6011 return fmt.Errorf("expected name to be of type string, got %T instead", value) 6012 } 6013 sv.SourceName = ptr.String(jtv) 6014 } 6015 6016 case "SourceObject": 6017 if value != nil { 6018 jtv, ok := value.(string) 6019 if !ok { 6020 return fmt.Errorf("expected name to be of type string, got %T instead", value) 6021 } 6022 sv.SourceObject = ptr.String(jtv) 6023 } 6024 6025 case "TemplateId": 6026 if value != nil { 6027 jtv, ok := value.(string) 6028 if !ok { 6029 return fmt.Errorf("expected name to be of type string, got %T instead", value) 6030 } 6031 sv.TemplateId = ptr.String(jtv) 6032 } 6033 6034 default: 6035 _, _ = key, value 6036 6037 } 6038 } 6039 *v = sv 6040 return nil 6041} 6042 6043func awsRestjson1_deserializeDocumentObjectTypeField(v **types.ObjectTypeField, value interface{}) error { 6044 if v == nil { 6045 return fmt.Errorf("unexpected nil of type %T", v) 6046 } 6047 if value == nil { 6048 return nil 6049 } 6050 6051 shape, ok := value.(map[string]interface{}) 6052 if !ok { 6053 return fmt.Errorf("unexpected JSON type %v", value) 6054 } 6055 6056 var sv *types.ObjectTypeField 6057 if *v == nil { 6058 sv = &types.ObjectTypeField{} 6059 } else { 6060 sv = *v 6061 } 6062 6063 for key, value := range shape { 6064 switch key { 6065 case "ContentType": 6066 if value != nil { 6067 jtv, ok := value.(string) 6068 if !ok { 6069 return fmt.Errorf("expected FieldContentType to be of type string, got %T instead", value) 6070 } 6071 sv.ContentType = types.FieldContentType(jtv) 6072 } 6073 6074 case "Source": 6075 if value != nil { 6076 jtv, ok := value.(string) 6077 if !ok { 6078 return fmt.Errorf("expected text to be of type string, got %T instead", value) 6079 } 6080 sv.Source = ptr.String(jtv) 6081 } 6082 6083 case "Target": 6084 if value != nil { 6085 jtv, ok := value.(string) 6086 if !ok { 6087 return fmt.Errorf("expected text to be of type string, got %T instead", value) 6088 } 6089 sv.Target = ptr.String(jtv) 6090 } 6091 6092 default: 6093 _, _ = key, value 6094 6095 } 6096 } 6097 *v = sv 6098 return nil 6099} 6100 6101func awsRestjson1_deserializeDocumentObjectTypeKey(v **types.ObjectTypeKey, value interface{}) error { 6102 if v == nil { 6103 return fmt.Errorf("unexpected nil of type %T", v) 6104 } 6105 if value == nil { 6106 return nil 6107 } 6108 6109 shape, ok := value.(map[string]interface{}) 6110 if !ok { 6111 return fmt.Errorf("unexpected JSON type %v", value) 6112 } 6113 6114 var sv *types.ObjectTypeKey 6115 if *v == nil { 6116 sv = &types.ObjectTypeKey{} 6117 } else { 6118 sv = *v 6119 } 6120 6121 for key, value := range shape { 6122 switch key { 6123 case "FieldNames": 6124 if err := awsRestjson1_deserializeDocumentFieldNameList(&sv.FieldNames, value); err != nil { 6125 return err 6126 } 6127 6128 case "StandardIdentifiers": 6129 if err := awsRestjson1_deserializeDocumentStandardIdentifierList(&sv.StandardIdentifiers, value); err != nil { 6130 return err 6131 } 6132 6133 default: 6134 _, _ = key, value 6135 6136 } 6137 } 6138 *v = sv 6139 return nil 6140} 6141 6142func awsRestjson1_deserializeDocumentObjectTypeKeyList(v *[]types.ObjectTypeKey, value interface{}) error { 6143 if v == nil { 6144 return fmt.Errorf("unexpected nil of type %T", v) 6145 } 6146 if value == nil { 6147 return nil 6148 } 6149 6150 shape, ok := value.([]interface{}) 6151 if !ok { 6152 return fmt.Errorf("unexpected JSON type %v", value) 6153 } 6154 6155 var cv []types.ObjectTypeKey 6156 if *v == nil { 6157 cv = []types.ObjectTypeKey{} 6158 } else { 6159 cv = *v 6160 } 6161 6162 for _, value := range shape { 6163 var col types.ObjectTypeKey 6164 destAddr := &col 6165 if err := awsRestjson1_deserializeDocumentObjectTypeKey(&destAddr, value); err != nil { 6166 return err 6167 } 6168 col = *destAddr 6169 cv = append(cv, col) 6170 6171 } 6172 *v = cv 6173 return nil 6174} 6175 6176func awsRestjson1_deserializeDocumentProfile(v **types.Profile, value interface{}) error { 6177 if v == nil { 6178 return fmt.Errorf("unexpected nil of type %T", v) 6179 } 6180 if value == nil { 6181 return nil 6182 } 6183 6184 shape, ok := value.(map[string]interface{}) 6185 if !ok { 6186 return fmt.Errorf("unexpected JSON type %v", value) 6187 } 6188 6189 var sv *types.Profile 6190 if *v == nil { 6191 sv = &types.Profile{} 6192 } else { 6193 sv = *v 6194 } 6195 6196 for key, value := range shape { 6197 switch key { 6198 case "AccountNumber": 6199 if value != nil { 6200 jtv, ok := value.(string) 6201 if !ok { 6202 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6203 } 6204 sv.AccountNumber = ptr.String(jtv) 6205 } 6206 6207 case "AdditionalInformation": 6208 if value != nil { 6209 jtv, ok := value.(string) 6210 if !ok { 6211 return fmt.Errorf("expected string1To1000 to be of type string, got %T instead", value) 6212 } 6213 sv.AdditionalInformation = ptr.String(jtv) 6214 } 6215 6216 case "Address": 6217 if err := awsRestjson1_deserializeDocumentAddress(&sv.Address, value); err != nil { 6218 return err 6219 } 6220 6221 case "Attributes": 6222 if err := awsRestjson1_deserializeDocumentAttributes(&sv.Attributes, value); err != nil { 6223 return err 6224 } 6225 6226 case "BillingAddress": 6227 if err := awsRestjson1_deserializeDocumentAddress(&sv.BillingAddress, value); err != nil { 6228 return err 6229 } 6230 6231 case "BirthDate": 6232 if value != nil { 6233 jtv, ok := value.(string) 6234 if !ok { 6235 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6236 } 6237 sv.BirthDate = ptr.String(jtv) 6238 } 6239 6240 case "BusinessEmailAddress": 6241 if value != nil { 6242 jtv, ok := value.(string) 6243 if !ok { 6244 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6245 } 6246 sv.BusinessEmailAddress = ptr.String(jtv) 6247 } 6248 6249 case "BusinessName": 6250 if value != nil { 6251 jtv, ok := value.(string) 6252 if !ok { 6253 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6254 } 6255 sv.BusinessName = ptr.String(jtv) 6256 } 6257 6258 case "BusinessPhoneNumber": 6259 if value != nil { 6260 jtv, ok := value.(string) 6261 if !ok { 6262 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6263 } 6264 sv.BusinessPhoneNumber = ptr.String(jtv) 6265 } 6266 6267 case "EmailAddress": 6268 if value != nil { 6269 jtv, ok := value.(string) 6270 if !ok { 6271 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6272 } 6273 sv.EmailAddress = ptr.String(jtv) 6274 } 6275 6276 case "FirstName": 6277 if value != nil { 6278 jtv, ok := value.(string) 6279 if !ok { 6280 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6281 } 6282 sv.FirstName = ptr.String(jtv) 6283 } 6284 6285 case "Gender": 6286 if value != nil { 6287 jtv, ok := value.(string) 6288 if !ok { 6289 return fmt.Errorf("expected Gender to be of type string, got %T instead", value) 6290 } 6291 sv.Gender = types.Gender(jtv) 6292 } 6293 6294 case "HomePhoneNumber": 6295 if value != nil { 6296 jtv, ok := value.(string) 6297 if !ok { 6298 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6299 } 6300 sv.HomePhoneNumber = ptr.String(jtv) 6301 } 6302 6303 case "LastName": 6304 if value != nil { 6305 jtv, ok := value.(string) 6306 if !ok { 6307 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6308 } 6309 sv.LastName = ptr.String(jtv) 6310 } 6311 6312 case "MailingAddress": 6313 if err := awsRestjson1_deserializeDocumentAddress(&sv.MailingAddress, value); err != nil { 6314 return err 6315 } 6316 6317 case "MiddleName": 6318 if value != nil { 6319 jtv, ok := value.(string) 6320 if !ok { 6321 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6322 } 6323 sv.MiddleName = ptr.String(jtv) 6324 } 6325 6326 case "MobilePhoneNumber": 6327 if value != nil { 6328 jtv, ok := value.(string) 6329 if !ok { 6330 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6331 } 6332 sv.MobilePhoneNumber = ptr.String(jtv) 6333 } 6334 6335 case "PartyType": 6336 if value != nil { 6337 jtv, ok := value.(string) 6338 if !ok { 6339 return fmt.Errorf("expected PartyType to be of type string, got %T instead", value) 6340 } 6341 sv.PartyType = types.PartyType(jtv) 6342 } 6343 6344 case "PersonalEmailAddress": 6345 if value != nil { 6346 jtv, ok := value.(string) 6347 if !ok { 6348 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6349 } 6350 sv.PersonalEmailAddress = ptr.String(jtv) 6351 } 6352 6353 case "PhoneNumber": 6354 if value != nil { 6355 jtv, ok := value.(string) 6356 if !ok { 6357 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6358 } 6359 sv.PhoneNumber = ptr.String(jtv) 6360 } 6361 6362 case "ProfileId": 6363 if value != nil { 6364 jtv, ok := value.(string) 6365 if !ok { 6366 return fmt.Errorf("expected uuid to be of type string, got %T instead", value) 6367 } 6368 sv.ProfileId = ptr.String(jtv) 6369 } 6370 6371 case "ShippingAddress": 6372 if err := awsRestjson1_deserializeDocumentAddress(&sv.ShippingAddress, value); err != nil { 6373 return err 6374 } 6375 6376 default: 6377 _, _ = key, value 6378 6379 } 6380 } 6381 *v = sv 6382 return nil 6383} 6384 6385func awsRestjson1_deserializeDocumentProfileList(v *[]types.Profile, value interface{}) error { 6386 if v == nil { 6387 return fmt.Errorf("unexpected nil of type %T", v) 6388 } 6389 if value == nil { 6390 return nil 6391 } 6392 6393 shape, ok := value.([]interface{}) 6394 if !ok { 6395 return fmt.Errorf("unexpected JSON type %v", value) 6396 } 6397 6398 var cv []types.Profile 6399 if *v == nil { 6400 cv = []types.Profile{} 6401 } else { 6402 cv = *v 6403 } 6404 6405 for _, value := range shape { 6406 var col types.Profile 6407 destAddr := &col 6408 if err := awsRestjson1_deserializeDocumentProfile(&destAddr, value); err != nil { 6409 return err 6410 } 6411 col = *destAddr 6412 cv = append(cv, col) 6413 6414 } 6415 *v = cv 6416 return nil 6417} 6418 6419func awsRestjson1_deserializeDocumentProfileObjectList(v *[]types.ListProfileObjectsItem, value interface{}) error { 6420 if v == nil { 6421 return fmt.Errorf("unexpected nil of type %T", v) 6422 } 6423 if value == nil { 6424 return nil 6425 } 6426 6427 shape, ok := value.([]interface{}) 6428 if !ok { 6429 return fmt.Errorf("unexpected JSON type %v", value) 6430 } 6431 6432 var cv []types.ListProfileObjectsItem 6433 if *v == nil { 6434 cv = []types.ListProfileObjectsItem{} 6435 } else { 6436 cv = *v 6437 } 6438 6439 for _, value := range shape { 6440 var col types.ListProfileObjectsItem 6441 destAddr := &col 6442 if err := awsRestjson1_deserializeDocumentListProfileObjectsItem(&destAddr, value); err != nil { 6443 return err 6444 } 6445 col = *destAddr 6446 cv = append(cv, col) 6447 6448 } 6449 *v = cv 6450 return nil 6451} 6452 6453func awsRestjson1_deserializeDocumentProfileObjectTypeList(v *[]types.ListProfileObjectTypeItem, value interface{}) error { 6454 if v == nil { 6455 return fmt.Errorf("unexpected nil of type %T", v) 6456 } 6457 if value == nil { 6458 return nil 6459 } 6460 6461 shape, ok := value.([]interface{}) 6462 if !ok { 6463 return fmt.Errorf("unexpected JSON type %v", value) 6464 } 6465 6466 var cv []types.ListProfileObjectTypeItem 6467 if *v == nil { 6468 cv = []types.ListProfileObjectTypeItem{} 6469 } else { 6470 cv = *v 6471 } 6472 6473 for _, value := range shape { 6474 var col types.ListProfileObjectTypeItem 6475 destAddr := &col 6476 if err := awsRestjson1_deserializeDocumentListProfileObjectTypeItem(&destAddr, value); err != nil { 6477 return err 6478 } 6479 col = *destAddr 6480 cv = append(cv, col) 6481 6482 } 6483 *v = cv 6484 return nil 6485} 6486 6487func awsRestjson1_deserializeDocumentProfileObjectTypeTemplateList(v *[]types.ListProfileObjectTypeTemplateItem, value interface{}) error { 6488 if v == nil { 6489 return fmt.Errorf("unexpected nil of type %T", v) 6490 } 6491 if value == nil { 6492 return nil 6493 } 6494 6495 shape, ok := value.([]interface{}) 6496 if !ok { 6497 return fmt.Errorf("unexpected JSON type %v", value) 6498 } 6499 6500 var cv []types.ListProfileObjectTypeTemplateItem 6501 if *v == nil { 6502 cv = []types.ListProfileObjectTypeTemplateItem{} 6503 } else { 6504 cv = *v 6505 } 6506 6507 for _, value := range shape { 6508 var col types.ListProfileObjectTypeTemplateItem 6509 destAddr := &col 6510 if err := awsRestjson1_deserializeDocumentListProfileObjectTypeTemplateItem(&destAddr, value); err != nil { 6511 return err 6512 } 6513 col = *destAddr 6514 cv = append(cv, col) 6515 6516 } 6517 *v = cv 6518 return nil 6519} 6520 6521func awsRestjson1_deserializeDocumentRequestValueList(v *[]string, value interface{}) error { 6522 if v == nil { 6523 return fmt.Errorf("unexpected nil of type %T", v) 6524 } 6525 if value == nil { 6526 return nil 6527 } 6528 6529 shape, ok := value.([]interface{}) 6530 if !ok { 6531 return fmt.Errorf("unexpected JSON type %v", value) 6532 } 6533 6534 var cv []string 6535 if *v == nil { 6536 cv = []string{} 6537 } else { 6538 cv = *v 6539 } 6540 6541 for _, value := range shape { 6542 var col string 6543 if value != nil { 6544 jtv, ok := value.(string) 6545 if !ok { 6546 return fmt.Errorf("expected string1To255 to be of type string, got %T instead", value) 6547 } 6548 col = jtv 6549 } 6550 cv = append(cv, col) 6551 6552 } 6553 *v = cv 6554 return nil 6555} 6556 6557func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 6558 if v == nil { 6559 return fmt.Errorf("unexpected nil of type %T", v) 6560 } 6561 if value == nil { 6562 return nil 6563 } 6564 6565 shape, ok := value.(map[string]interface{}) 6566 if !ok { 6567 return fmt.Errorf("unexpected JSON type %v", value) 6568 } 6569 6570 var sv *types.ResourceNotFoundException 6571 if *v == nil { 6572 sv = &types.ResourceNotFoundException{} 6573 } else { 6574 sv = *v 6575 } 6576 6577 for key, value := range shape { 6578 switch key { 6579 case "Message": 6580 if value != nil { 6581 jtv, ok := value.(string) 6582 if !ok { 6583 return fmt.Errorf("expected message to be of type string, got %T instead", value) 6584 } 6585 sv.Message = ptr.String(jtv) 6586 } 6587 6588 default: 6589 _, _ = key, value 6590 6591 } 6592 } 6593 *v = sv 6594 return nil 6595} 6596 6597func awsRestjson1_deserializeDocumentStandardIdentifierList(v *[]types.StandardIdentifier, value interface{}) error { 6598 if v == nil { 6599 return fmt.Errorf("unexpected nil of type %T", v) 6600 } 6601 if value == nil { 6602 return nil 6603 } 6604 6605 shape, ok := value.([]interface{}) 6606 if !ok { 6607 return fmt.Errorf("unexpected JSON type %v", value) 6608 } 6609 6610 var cv []types.StandardIdentifier 6611 if *v == nil { 6612 cv = []types.StandardIdentifier{} 6613 } else { 6614 cv = *v 6615 } 6616 6617 for _, value := range shape { 6618 var col types.StandardIdentifier 6619 if value != nil { 6620 jtv, ok := value.(string) 6621 if !ok { 6622 return fmt.Errorf("expected StandardIdentifier to be of type string, got %T instead", value) 6623 } 6624 col = types.StandardIdentifier(jtv) 6625 } 6626 cv = append(cv, col) 6627 6628 } 6629 *v = cv 6630 return nil 6631} 6632 6633func awsRestjson1_deserializeDocumentTagMap(v *map[string]string, value interface{}) error { 6634 if v == nil { 6635 return fmt.Errorf("unexpected nil of type %T", v) 6636 } 6637 if value == nil { 6638 return nil 6639 } 6640 6641 shape, ok := value.(map[string]interface{}) 6642 if !ok { 6643 return fmt.Errorf("unexpected JSON type %v", value) 6644 } 6645 6646 var mv map[string]string 6647 if *v == nil { 6648 mv = map[string]string{} 6649 } else { 6650 mv = *v 6651 } 6652 6653 for key, value := range shape { 6654 var parsedVal string 6655 if value != nil { 6656 jtv, ok := value.(string) 6657 if !ok { 6658 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 6659 } 6660 parsedVal = jtv 6661 } 6662 mv[key] = parsedVal 6663 6664 } 6665 *v = mv 6666 return nil 6667} 6668 6669func awsRestjson1_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 6670 if v == nil { 6671 return fmt.Errorf("unexpected nil of type %T", v) 6672 } 6673 if value == nil { 6674 return nil 6675 } 6676 6677 shape, ok := value.(map[string]interface{}) 6678 if !ok { 6679 return fmt.Errorf("unexpected JSON type %v", value) 6680 } 6681 6682 var sv *types.ThrottlingException 6683 if *v == nil { 6684 sv = &types.ThrottlingException{} 6685 } else { 6686 sv = *v 6687 } 6688 6689 for key, value := range shape { 6690 switch key { 6691 case "Message": 6692 if value != nil { 6693 jtv, ok := value.(string) 6694 if !ok { 6695 return fmt.Errorf("expected message to be of type string, got %T instead", value) 6696 } 6697 sv.Message = ptr.String(jtv) 6698 } 6699 6700 default: 6701 _, _ = key, value 6702 6703 } 6704 } 6705 *v = sv 6706 return nil 6707} 6708