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