1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ivs 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/ivs/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_deserializeOpBatchGetChannel struct { 24} 25 26func (*awsRestjson1_deserializeOpBatchGetChannel) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsRestjson1_deserializeOpBatchGetChannel) 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_deserializeOpErrorBatchGetChannel(response, &metadata) 45 } 46 output := &BatchGetChannelOutput{} 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_deserializeOpDocumentBatchGetChannelOutput(&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_deserializeOpErrorBatchGetChannel(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 default: 122 genericError := &smithy.GenericAPIError{ 123 Code: errorCode, 124 Message: errorMessage, 125 } 126 return genericError 127 128 } 129} 130 131func awsRestjson1_deserializeOpDocumentBatchGetChannelOutput(v **BatchGetChannelOutput, value interface{}) error { 132 if v == nil { 133 return fmt.Errorf("unexpected nil of type %T", v) 134 } 135 if value == nil { 136 return nil 137 } 138 139 shape, ok := value.(map[string]interface{}) 140 if !ok { 141 return fmt.Errorf("unexpected JSON type %v", value) 142 } 143 144 var sv *BatchGetChannelOutput 145 if *v == nil { 146 sv = &BatchGetChannelOutput{} 147 } else { 148 sv = *v 149 } 150 151 for key, value := range shape { 152 switch key { 153 case "channels": 154 if err := awsRestjson1_deserializeDocumentChannels(&sv.Channels, value); err != nil { 155 return err 156 } 157 158 case "errors": 159 if err := awsRestjson1_deserializeDocumentBatchErrors(&sv.Errors, value); err != nil { 160 return err 161 } 162 163 default: 164 _, _ = key, value 165 166 } 167 } 168 *v = sv 169 return nil 170} 171 172type awsRestjson1_deserializeOpBatchGetStreamKey struct { 173} 174 175func (*awsRestjson1_deserializeOpBatchGetStreamKey) ID() string { 176 return "OperationDeserializer" 177} 178 179func (m *awsRestjson1_deserializeOpBatchGetStreamKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 180 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 181) { 182 out, metadata, err = next.HandleDeserialize(ctx, in) 183 if err != nil { 184 return out, metadata, err 185 } 186 187 response, ok := out.RawResponse.(*smithyhttp.Response) 188 if !ok { 189 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 190 } 191 192 if response.StatusCode < 200 || response.StatusCode >= 300 { 193 return out, metadata, awsRestjson1_deserializeOpErrorBatchGetStreamKey(response, &metadata) 194 } 195 output := &BatchGetStreamKeyOutput{} 196 out.Result = output 197 198 var buff [1024]byte 199 ringBuffer := smithyio.NewRingBuffer(buff[:]) 200 201 body := io.TeeReader(response.Body, ringBuffer) 202 203 decoder := json.NewDecoder(body) 204 decoder.UseNumber() 205 var shape interface{} 206 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 207 var snapshot bytes.Buffer 208 io.Copy(&snapshot, ringBuffer) 209 err = &smithy.DeserializationError{ 210 Err: fmt.Errorf("failed to decode response body, %w", err), 211 Snapshot: snapshot.Bytes(), 212 } 213 return out, metadata, err 214 } 215 216 err = awsRestjson1_deserializeOpDocumentBatchGetStreamKeyOutput(&output, shape) 217 if err != nil { 218 var snapshot bytes.Buffer 219 io.Copy(&snapshot, ringBuffer) 220 return out, metadata, &smithy.DeserializationError{ 221 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 222 Snapshot: snapshot.Bytes(), 223 } 224 } 225 226 return out, metadata, err 227} 228 229func awsRestjson1_deserializeOpErrorBatchGetStreamKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 230 var errorBuffer bytes.Buffer 231 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 232 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 233 } 234 errorBody := bytes.NewReader(errorBuffer.Bytes()) 235 236 errorCode := "UnknownError" 237 errorMessage := errorCode 238 239 code := response.Header.Get("X-Amzn-ErrorType") 240 if len(code) != 0 { 241 errorCode = restjson.SanitizeErrorCode(code) 242 } 243 244 var buff [1024]byte 245 ringBuffer := smithyio.NewRingBuffer(buff[:]) 246 247 body := io.TeeReader(errorBody, ringBuffer) 248 decoder := json.NewDecoder(body) 249 decoder.UseNumber() 250 code, message, err := restjson.GetErrorInfo(decoder) 251 if err != nil { 252 var snapshot bytes.Buffer 253 io.Copy(&snapshot, ringBuffer) 254 err = &smithy.DeserializationError{ 255 Err: fmt.Errorf("failed to decode response body, %w", err), 256 Snapshot: snapshot.Bytes(), 257 } 258 return err 259 } 260 261 errorBody.Seek(0, io.SeekStart) 262 if len(code) != 0 { 263 errorCode = restjson.SanitizeErrorCode(code) 264 } 265 if len(message) != 0 { 266 errorMessage = message 267 } 268 269 switch { 270 default: 271 genericError := &smithy.GenericAPIError{ 272 Code: errorCode, 273 Message: errorMessage, 274 } 275 return genericError 276 277 } 278} 279 280func awsRestjson1_deserializeOpDocumentBatchGetStreamKeyOutput(v **BatchGetStreamKeyOutput, value interface{}) error { 281 if v == nil { 282 return fmt.Errorf("unexpected nil of type %T", v) 283 } 284 if value == nil { 285 return nil 286 } 287 288 shape, ok := value.(map[string]interface{}) 289 if !ok { 290 return fmt.Errorf("unexpected JSON type %v", value) 291 } 292 293 var sv *BatchGetStreamKeyOutput 294 if *v == nil { 295 sv = &BatchGetStreamKeyOutput{} 296 } else { 297 sv = *v 298 } 299 300 for key, value := range shape { 301 switch key { 302 case "errors": 303 if err := awsRestjson1_deserializeDocumentBatchErrors(&sv.Errors, value); err != nil { 304 return err 305 } 306 307 case "streamKeys": 308 if err := awsRestjson1_deserializeDocumentStreamKeys(&sv.StreamKeys, value); err != nil { 309 return err 310 } 311 312 default: 313 _, _ = key, value 314 315 } 316 } 317 *v = sv 318 return nil 319} 320 321type awsRestjson1_deserializeOpCreateChannel struct { 322} 323 324func (*awsRestjson1_deserializeOpCreateChannel) ID() string { 325 return "OperationDeserializer" 326} 327 328func (m *awsRestjson1_deserializeOpCreateChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 329 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 330) { 331 out, metadata, err = next.HandleDeserialize(ctx, in) 332 if err != nil { 333 return out, metadata, err 334 } 335 336 response, ok := out.RawResponse.(*smithyhttp.Response) 337 if !ok { 338 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 339 } 340 341 if response.StatusCode < 200 || response.StatusCode >= 300 { 342 return out, metadata, awsRestjson1_deserializeOpErrorCreateChannel(response, &metadata) 343 } 344 output := &CreateChannelOutput{} 345 out.Result = output 346 347 var buff [1024]byte 348 ringBuffer := smithyio.NewRingBuffer(buff[:]) 349 350 body := io.TeeReader(response.Body, ringBuffer) 351 352 decoder := json.NewDecoder(body) 353 decoder.UseNumber() 354 var shape interface{} 355 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 356 var snapshot bytes.Buffer 357 io.Copy(&snapshot, ringBuffer) 358 err = &smithy.DeserializationError{ 359 Err: fmt.Errorf("failed to decode response body, %w", err), 360 Snapshot: snapshot.Bytes(), 361 } 362 return out, metadata, err 363 } 364 365 err = awsRestjson1_deserializeOpDocumentCreateChannelOutput(&output, shape) 366 if err != nil { 367 var snapshot bytes.Buffer 368 io.Copy(&snapshot, ringBuffer) 369 return out, metadata, &smithy.DeserializationError{ 370 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 371 Snapshot: snapshot.Bytes(), 372 } 373 } 374 375 return out, metadata, err 376} 377 378func awsRestjson1_deserializeOpErrorCreateChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 379 var errorBuffer bytes.Buffer 380 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 381 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 382 } 383 errorBody := bytes.NewReader(errorBuffer.Bytes()) 384 385 errorCode := "UnknownError" 386 errorMessage := errorCode 387 388 code := response.Header.Get("X-Amzn-ErrorType") 389 if len(code) != 0 { 390 errorCode = restjson.SanitizeErrorCode(code) 391 } 392 393 var buff [1024]byte 394 ringBuffer := smithyio.NewRingBuffer(buff[:]) 395 396 body := io.TeeReader(errorBody, ringBuffer) 397 decoder := json.NewDecoder(body) 398 decoder.UseNumber() 399 code, message, err := restjson.GetErrorInfo(decoder) 400 if err != nil { 401 var snapshot bytes.Buffer 402 io.Copy(&snapshot, ringBuffer) 403 err = &smithy.DeserializationError{ 404 Err: fmt.Errorf("failed to decode response body, %w", err), 405 Snapshot: snapshot.Bytes(), 406 } 407 return err 408 } 409 410 errorBody.Seek(0, io.SeekStart) 411 if len(code) != 0 { 412 errorCode = restjson.SanitizeErrorCode(code) 413 } 414 if len(message) != 0 { 415 errorMessage = message 416 } 417 418 switch { 419 case strings.EqualFold("AccessDeniedException", errorCode): 420 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 421 422 case strings.EqualFold("PendingVerification", errorCode): 423 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 424 425 case strings.EqualFold("ResourceNotFoundException", errorCode): 426 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 427 428 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 429 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 430 431 case strings.EqualFold("ValidationException", errorCode): 432 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 433 434 default: 435 genericError := &smithy.GenericAPIError{ 436 Code: errorCode, 437 Message: errorMessage, 438 } 439 return genericError 440 441 } 442} 443 444func awsRestjson1_deserializeOpDocumentCreateChannelOutput(v **CreateChannelOutput, value interface{}) error { 445 if v == nil { 446 return fmt.Errorf("unexpected nil of type %T", v) 447 } 448 if value == nil { 449 return nil 450 } 451 452 shape, ok := value.(map[string]interface{}) 453 if !ok { 454 return fmt.Errorf("unexpected JSON type %v", value) 455 } 456 457 var sv *CreateChannelOutput 458 if *v == nil { 459 sv = &CreateChannelOutput{} 460 } else { 461 sv = *v 462 } 463 464 for key, value := range shape { 465 switch key { 466 case "channel": 467 if err := awsRestjson1_deserializeDocumentChannel(&sv.Channel, value); err != nil { 468 return err 469 } 470 471 case "streamKey": 472 if err := awsRestjson1_deserializeDocumentStreamKey(&sv.StreamKey, value); err != nil { 473 return err 474 } 475 476 default: 477 _, _ = key, value 478 479 } 480 } 481 *v = sv 482 return nil 483} 484 485type awsRestjson1_deserializeOpCreateRecordingConfiguration struct { 486} 487 488func (*awsRestjson1_deserializeOpCreateRecordingConfiguration) ID() string { 489 return "OperationDeserializer" 490} 491 492func (m *awsRestjson1_deserializeOpCreateRecordingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 493 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 494) { 495 out, metadata, err = next.HandleDeserialize(ctx, in) 496 if err != nil { 497 return out, metadata, err 498 } 499 500 response, ok := out.RawResponse.(*smithyhttp.Response) 501 if !ok { 502 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 503 } 504 505 if response.StatusCode < 200 || response.StatusCode >= 300 { 506 return out, metadata, awsRestjson1_deserializeOpErrorCreateRecordingConfiguration(response, &metadata) 507 } 508 output := &CreateRecordingConfigurationOutput{} 509 out.Result = output 510 511 var buff [1024]byte 512 ringBuffer := smithyio.NewRingBuffer(buff[:]) 513 514 body := io.TeeReader(response.Body, ringBuffer) 515 516 decoder := json.NewDecoder(body) 517 decoder.UseNumber() 518 var shape interface{} 519 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 520 var snapshot bytes.Buffer 521 io.Copy(&snapshot, ringBuffer) 522 err = &smithy.DeserializationError{ 523 Err: fmt.Errorf("failed to decode response body, %w", err), 524 Snapshot: snapshot.Bytes(), 525 } 526 return out, metadata, err 527 } 528 529 err = awsRestjson1_deserializeOpDocumentCreateRecordingConfigurationOutput(&output, shape) 530 if err != nil { 531 var snapshot bytes.Buffer 532 io.Copy(&snapshot, ringBuffer) 533 return out, metadata, &smithy.DeserializationError{ 534 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 535 Snapshot: snapshot.Bytes(), 536 } 537 } 538 539 return out, metadata, err 540} 541 542func awsRestjson1_deserializeOpErrorCreateRecordingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 543 var errorBuffer bytes.Buffer 544 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 545 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 546 } 547 errorBody := bytes.NewReader(errorBuffer.Bytes()) 548 549 errorCode := "UnknownError" 550 errorMessage := errorCode 551 552 code := response.Header.Get("X-Amzn-ErrorType") 553 if len(code) != 0 { 554 errorCode = restjson.SanitizeErrorCode(code) 555 } 556 557 var buff [1024]byte 558 ringBuffer := smithyio.NewRingBuffer(buff[:]) 559 560 body := io.TeeReader(errorBody, ringBuffer) 561 decoder := json.NewDecoder(body) 562 decoder.UseNumber() 563 code, message, err := restjson.GetErrorInfo(decoder) 564 if err != nil { 565 var snapshot bytes.Buffer 566 io.Copy(&snapshot, ringBuffer) 567 err = &smithy.DeserializationError{ 568 Err: fmt.Errorf("failed to decode response body, %w", err), 569 Snapshot: snapshot.Bytes(), 570 } 571 return err 572 } 573 574 errorBody.Seek(0, io.SeekStart) 575 if len(code) != 0 { 576 errorCode = restjson.SanitizeErrorCode(code) 577 } 578 if len(message) != 0 { 579 errorMessage = message 580 } 581 582 switch { 583 case strings.EqualFold("AccessDeniedException", errorCode): 584 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 585 586 case strings.EqualFold("ConflictException", errorCode): 587 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 588 589 case strings.EqualFold("InternalServerException", errorCode): 590 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 591 592 case strings.EqualFold("PendingVerification", errorCode): 593 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 594 595 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 596 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 597 598 case strings.EqualFold("ValidationException", errorCode): 599 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 600 601 default: 602 genericError := &smithy.GenericAPIError{ 603 Code: errorCode, 604 Message: errorMessage, 605 } 606 return genericError 607 608 } 609} 610 611func awsRestjson1_deserializeOpDocumentCreateRecordingConfigurationOutput(v **CreateRecordingConfigurationOutput, value interface{}) error { 612 if v == nil { 613 return fmt.Errorf("unexpected nil of type %T", v) 614 } 615 if value == nil { 616 return nil 617 } 618 619 shape, ok := value.(map[string]interface{}) 620 if !ok { 621 return fmt.Errorf("unexpected JSON type %v", value) 622 } 623 624 var sv *CreateRecordingConfigurationOutput 625 if *v == nil { 626 sv = &CreateRecordingConfigurationOutput{} 627 } else { 628 sv = *v 629 } 630 631 for key, value := range shape { 632 switch key { 633 case "recordingConfiguration": 634 if err := awsRestjson1_deserializeDocumentRecordingConfiguration(&sv.RecordingConfiguration, value); err != nil { 635 return err 636 } 637 638 default: 639 _, _ = key, value 640 641 } 642 } 643 *v = sv 644 return nil 645} 646 647type awsRestjson1_deserializeOpCreateStreamKey struct { 648} 649 650func (*awsRestjson1_deserializeOpCreateStreamKey) ID() string { 651 return "OperationDeserializer" 652} 653 654func (m *awsRestjson1_deserializeOpCreateStreamKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 655 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 656) { 657 out, metadata, err = next.HandleDeserialize(ctx, in) 658 if err != nil { 659 return out, metadata, err 660 } 661 662 response, ok := out.RawResponse.(*smithyhttp.Response) 663 if !ok { 664 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 665 } 666 667 if response.StatusCode < 200 || response.StatusCode >= 300 { 668 return out, metadata, awsRestjson1_deserializeOpErrorCreateStreamKey(response, &metadata) 669 } 670 output := &CreateStreamKeyOutput{} 671 out.Result = output 672 673 var buff [1024]byte 674 ringBuffer := smithyio.NewRingBuffer(buff[:]) 675 676 body := io.TeeReader(response.Body, ringBuffer) 677 678 decoder := json.NewDecoder(body) 679 decoder.UseNumber() 680 var shape interface{} 681 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 682 var snapshot bytes.Buffer 683 io.Copy(&snapshot, ringBuffer) 684 err = &smithy.DeserializationError{ 685 Err: fmt.Errorf("failed to decode response body, %w", err), 686 Snapshot: snapshot.Bytes(), 687 } 688 return out, metadata, err 689 } 690 691 err = awsRestjson1_deserializeOpDocumentCreateStreamKeyOutput(&output, shape) 692 if err != nil { 693 var snapshot bytes.Buffer 694 io.Copy(&snapshot, ringBuffer) 695 return out, metadata, &smithy.DeserializationError{ 696 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 697 Snapshot: snapshot.Bytes(), 698 } 699 } 700 701 return out, metadata, err 702} 703 704func awsRestjson1_deserializeOpErrorCreateStreamKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 705 var errorBuffer bytes.Buffer 706 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 707 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 708 } 709 errorBody := bytes.NewReader(errorBuffer.Bytes()) 710 711 errorCode := "UnknownError" 712 errorMessage := errorCode 713 714 code := response.Header.Get("X-Amzn-ErrorType") 715 if len(code) != 0 { 716 errorCode = restjson.SanitizeErrorCode(code) 717 } 718 719 var buff [1024]byte 720 ringBuffer := smithyio.NewRingBuffer(buff[:]) 721 722 body := io.TeeReader(errorBody, ringBuffer) 723 decoder := json.NewDecoder(body) 724 decoder.UseNumber() 725 code, message, err := restjson.GetErrorInfo(decoder) 726 if err != nil { 727 var snapshot bytes.Buffer 728 io.Copy(&snapshot, ringBuffer) 729 err = &smithy.DeserializationError{ 730 Err: fmt.Errorf("failed to decode response body, %w", err), 731 Snapshot: snapshot.Bytes(), 732 } 733 return err 734 } 735 736 errorBody.Seek(0, io.SeekStart) 737 if len(code) != 0 { 738 errorCode = restjson.SanitizeErrorCode(code) 739 } 740 if len(message) != 0 { 741 errorMessage = message 742 } 743 744 switch { 745 case strings.EqualFold("AccessDeniedException", errorCode): 746 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 747 748 case strings.EqualFold("PendingVerification", errorCode): 749 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 750 751 case strings.EqualFold("ResourceNotFoundException", errorCode): 752 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 753 754 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 755 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 756 757 case strings.EqualFold("ValidationException", errorCode): 758 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 759 760 default: 761 genericError := &smithy.GenericAPIError{ 762 Code: errorCode, 763 Message: errorMessage, 764 } 765 return genericError 766 767 } 768} 769 770func awsRestjson1_deserializeOpDocumentCreateStreamKeyOutput(v **CreateStreamKeyOutput, value interface{}) error { 771 if v == nil { 772 return fmt.Errorf("unexpected nil of type %T", v) 773 } 774 if value == nil { 775 return nil 776 } 777 778 shape, ok := value.(map[string]interface{}) 779 if !ok { 780 return fmt.Errorf("unexpected JSON type %v", value) 781 } 782 783 var sv *CreateStreamKeyOutput 784 if *v == nil { 785 sv = &CreateStreamKeyOutput{} 786 } else { 787 sv = *v 788 } 789 790 for key, value := range shape { 791 switch key { 792 case "streamKey": 793 if err := awsRestjson1_deserializeDocumentStreamKey(&sv.StreamKey, value); err != nil { 794 return err 795 } 796 797 default: 798 _, _ = key, value 799 800 } 801 } 802 *v = sv 803 return nil 804} 805 806type awsRestjson1_deserializeOpDeleteChannel struct { 807} 808 809func (*awsRestjson1_deserializeOpDeleteChannel) ID() string { 810 return "OperationDeserializer" 811} 812 813func (m *awsRestjson1_deserializeOpDeleteChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 814 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 815) { 816 out, metadata, err = next.HandleDeserialize(ctx, in) 817 if err != nil { 818 return out, metadata, err 819 } 820 821 response, ok := out.RawResponse.(*smithyhttp.Response) 822 if !ok { 823 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 824 } 825 826 if response.StatusCode < 200 || response.StatusCode >= 300 { 827 return out, metadata, awsRestjson1_deserializeOpErrorDeleteChannel(response, &metadata) 828 } 829 output := &DeleteChannelOutput{} 830 out.Result = output 831 832 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 833 return out, metadata, &smithy.DeserializationError{ 834 Err: fmt.Errorf("failed to discard response body, %w", err), 835 } 836 } 837 838 return out, metadata, err 839} 840 841func awsRestjson1_deserializeOpErrorDeleteChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 842 var errorBuffer bytes.Buffer 843 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 844 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 845 } 846 errorBody := bytes.NewReader(errorBuffer.Bytes()) 847 848 errorCode := "UnknownError" 849 errorMessage := errorCode 850 851 code := response.Header.Get("X-Amzn-ErrorType") 852 if len(code) != 0 { 853 errorCode = restjson.SanitizeErrorCode(code) 854 } 855 856 var buff [1024]byte 857 ringBuffer := smithyio.NewRingBuffer(buff[:]) 858 859 body := io.TeeReader(errorBody, ringBuffer) 860 decoder := json.NewDecoder(body) 861 decoder.UseNumber() 862 code, message, err := restjson.GetErrorInfo(decoder) 863 if err != nil { 864 var snapshot bytes.Buffer 865 io.Copy(&snapshot, ringBuffer) 866 err = &smithy.DeserializationError{ 867 Err: fmt.Errorf("failed to decode response body, %w", err), 868 Snapshot: snapshot.Bytes(), 869 } 870 return err 871 } 872 873 errorBody.Seek(0, io.SeekStart) 874 if len(code) != 0 { 875 errorCode = restjson.SanitizeErrorCode(code) 876 } 877 if len(message) != 0 { 878 errorMessage = message 879 } 880 881 switch { 882 case strings.EqualFold("AccessDeniedException", errorCode): 883 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 884 885 case strings.EqualFold("ConflictException", errorCode): 886 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 887 888 case strings.EqualFold("PendingVerification", errorCode): 889 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 890 891 case strings.EqualFold("ResourceNotFoundException", errorCode): 892 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 893 894 case strings.EqualFold("ValidationException", errorCode): 895 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 896 897 default: 898 genericError := &smithy.GenericAPIError{ 899 Code: errorCode, 900 Message: errorMessage, 901 } 902 return genericError 903 904 } 905} 906 907type awsRestjson1_deserializeOpDeletePlaybackKeyPair struct { 908} 909 910func (*awsRestjson1_deserializeOpDeletePlaybackKeyPair) ID() string { 911 return "OperationDeserializer" 912} 913 914func (m *awsRestjson1_deserializeOpDeletePlaybackKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 915 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 916) { 917 out, metadata, err = next.HandleDeserialize(ctx, in) 918 if err != nil { 919 return out, metadata, err 920 } 921 922 response, ok := out.RawResponse.(*smithyhttp.Response) 923 if !ok { 924 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 925 } 926 927 if response.StatusCode < 200 || response.StatusCode >= 300 { 928 return out, metadata, awsRestjson1_deserializeOpErrorDeletePlaybackKeyPair(response, &metadata) 929 } 930 output := &DeletePlaybackKeyPairOutput{} 931 out.Result = output 932 933 return out, metadata, err 934} 935 936func awsRestjson1_deserializeOpErrorDeletePlaybackKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error { 937 var errorBuffer bytes.Buffer 938 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 939 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 940 } 941 errorBody := bytes.NewReader(errorBuffer.Bytes()) 942 943 errorCode := "UnknownError" 944 errorMessage := errorCode 945 946 code := response.Header.Get("X-Amzn-ErrorType") 947 if len(code) != 0 { 948 errorCode = restjson.SanitizeErrorCode(code) 949 } 950 951 var buff [1024]byte 952 ringBuffer := smithyio.NewRingBuffer(buff[:]) 953 954 body := io.TeeReader(errorBody, ringBuffer) 955 decoder := json.NewDecoder(body) 956 decoder.UseNumber() 957 code, message, err := restjson.GetErrorInfo(decoder) 958 if err != nil { 959 var snapshot bytes.Buffer 960 io.Copy(&snapshot, ringBuffer) 961 err = &smithy.DeserializationError{ 962 Err: fmt.Errorf("failed to decode response body, %w", err), 963 Snapshot: snapshot.Bytes(), 964 } 965 return err 966 } 967 968 errorBody.Seek(0, io.SeekStart) 969 if len(code) != 0 { 970 errorCode = restjson.SanitizeErrorCode(code) 971 } 972 if len(message) != 0 { 973 errorMessage = message 974 } 975 976 switch { 977 case strings.EqualFold("AccessDeniedException", errorCode): 978 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 979 980 case strings.EqualFold("PendingVerification", errorCode): 981 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 982 983 case strings.EqualFold("ResourceNotFoundException", errorCode): 984 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 985 986 case strings.EqualFold("ValidationException", errorCode): 987 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 988 989 default: 990 genericError := &smithy.GenericAPIError{ 991 Code: errorCode, 992 Message: errorMessage, 993 } 994 return genericError 995 996 } 997} 998 999type awsRestjson1_deserializeOpDeleteRecordingConfiguration struct { 1000} 1001 1002func (*awsRestjson1_deserializeOpDeleteRecordingConfiguration) ID() string { 1003 return "OperationDeserializer" 1004} 1005 1006func (m *awsRestjson1_deserializeOpDeleteRecordingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1007 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1008) { 1009 out, metadata, err = next.HandleDeserialize(ctx, in) 1010 if err != nil { 1011 return out, metadata, err 1012 } 1013 1014 response, ok := out.RawResponse.(*smithyhttp.Response) 1015 if !ok { 1016 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1017 } 1018 1019 if response.StatusCode < 200 || response.StatusCode >= 300 { 1020 return out, metadata, awsRestjson1_deserializeOpErrorDeleteRecordingConfiguration(response, &metadata) 1021 } 1022 output := &DeleteRecordingConfigurationOutput{} 1023 out.Result = output 1024 1025 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1026 return out, metadata, &smithy.DeserializationError{ 1027 Err: fmt.Errorf("failed to discard response body, %w", err), 1028 } 1029 } 1030 1031 return out, metadata, err 1032} 1033 1034func awsRestjson1_deserializeOpErrorDeleteRecordingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1035 var errorBuffer bytes.Buffer 1036 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1037 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1038 } 1039 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1040 1041 errorCode := "UnknownError" 1042 errorMessage := errorCode 1043 1044 code := response.Header.Get("X-Amzn-ErrorType") 1045 if len(code) != 0 { 1046 errorCode = restjson.SanitizeErrorCode(code) 1047 } 1048 1049 var buff [1024]byte 1050 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1051 1052 body := io.TeeReader(errorBody, ringBuffer) 1053 decoder := json.NewDecoder(body) 1054 decoder.UseNumber() 1055 code, message, err := restjson.GetErrorInfo(decoder) 1056 if err != nil { 1057 var snapshot bytes.Buffer 1058 io.Copy(&snapshot, ringBuffer) 1059 err = &smithy.DeserializationError{ 1060 Err: fmt.Errorf("failed to decode response body, %w", err), 1061 Snapshot: snapshot.Bytes(), 1062 } 1063 return err 1064 } 1065 1066 errorBody.Seek(0, io.SeekStart) 1067 if len(code) != 0 { 1068 errorCode = restjson.SanitizeErrorCode(code) 1069 } 1070 if len(message) != 0 { 1071 errorMessage = message 1072 } 1073 1074 switch { 1075 case strings.EqualFold("AccessDeniedException", errorCode): 1076 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1077 1078 case strings.EqualFold("ConflictException", errorCode): 1079 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1080 1081 case strings.EqualFold("InternalServerException", errorCode): 1082 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1083 1084 case strings.EqualFold("ResourceNotFoundException", errorCode): 1085 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1086 1087 case strings.EqualFold("ValidationException", errorCode): 1088 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1089 1090 default: 1091 genericError := &smithy.GenericAPIError{ 1092 Code: errorCode, 1093 Message: errorMessage, 1094 } 1095 return genericError 1096 1097 } 1098} 1099 1100type awsRestjson1_deserializeOpDeleteStreamKey struct { 1101} 1102 1103func (*awsRestjson1_deserializeOpDeleteStreamKey) ID() string { 1104 return "OperationDeserializer" 1105} 1106 1107func (m *awsRestjson1_deserializeOpDeleteStreamKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1108 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1109) { 1110 out, metadata, err = next.HandleDeserialize(ctx, in) 1111 if err != nil { 1112 return out, metadata, err 1113 } 1114 1115 response, ok := out.RawResponse.(*smithyhttp.Response) 1116 if !ok { 1117 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1118 } 1119 1120 if response.StatusCode < 200 || response.StatusCode >= 300 { 1121 return out, metadata, awsRestjson1_deserializeOpErrorDeleteStreamKey(response, &metadata) 1122 } 1123 output := &DeleteStreamKeyOutput{} 1124 out.Result = output 1125 1126 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1127 return out, metadata, &smithy.DeserializationError{ 1128 Err: fmt.Errorf("failed to discard response body, %w", err), 1129 } 1130 } 1131 1132 return out, metadata, err 1133} 1134 1135func awsRestjson1_deserializeOpErrorDeleteStreamKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1136 var errorBuffer bytes.Buffer 1137 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1138 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1139 } 1140 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1141 1142 errorCode := "UnknownError" 1143 errorMessage := errorCode 1144 1145 code := response.Header.Get("X-Amzn-ErrorType") 1146 if len(code) != 0 { 1147 errorCode = restjson.SanitizeErrorCode(code) 1148 } 1149 1150 var buff [1024]byte 1151 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1152 1153 body := io.TeeReader(errorBody, ringBuffer) 1154 decoder := json.NewDecoder(body) 1155 decoder.UseNumber() 1156 code, message, err := restjson.GetErrorInfo(decoder) 1157 if err != nil { 1158 var snapshot bytes.Buffer 1159 io.Copy(&snapshot, ringBuffer) 1160 err = &smithy.DeserializationError{ 1161 Err: fmt.Errorf("failed to decode response body, %w", err), 1162 Snapshot: snapshot.Bytes(), 1163 } 1164 return err 1165 } 1166 1167 errorBody.Seek(0, io.SeekStart) 1168 if len(code) != 0 { 1169 errorCode = restjson.SanitizeErrorCode(code) 1170 } 1171 if len(message) != 0 { 1172 errorMessage = message 1173 } 1174 1175 switch { 1176 case strings.EqualFold("AccessDeniedException", errorCode): 1177 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1178 1179 case strings.EqualFold("PendingVerification", errorCode): 1180 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 1181 1182 case strings.EqualFold("ResourceNotFoundException", errorCode): 1183 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1184 1185 case strings.EqualFold("ValidationException", errorCode): 1186 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1187 1188 default: 1189 genericError := &smithy.GenericAPIError{ 1190 Code: errorCode, 1191 Message: errorMessage, 1192 } 1193 return genericError 1194 1195 } 1196} 1197 1198type awsRestjson1_deserializeOpGetChannel struct { 1199} 1200 1201func (*awsRestjson1_deserializeOpGetChannel) ID() string { 1202 return "OperationDeserializer" 1203} 1204 1205func (m *awsRestjson1_deserializeOpGetChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1206 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1207) { 1208 out, metadata, err = next.HandleDeserialize(ctx, in) 1209 if err != nil { 1210 return out, metadata, err 1211 } 1212 1213 response, ok := out.RawResponse.(*smithyhttp.Response) 1214 if !ok { 1215 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1216 } 1217 1218 if response.StatusCode < 200 || response.StatusCode >= 300 { 1219 return out, metadata, awsRestjson1_deserializeOpErrorGetChannel(response, &metadata) 1220 } 1221 output := &GetChannelOutput{} 1222 out.Result = output 1223 1224 var buff [1024]byte 1225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1226 1227 body := io.TeeReader(response.Body, ringBuffer) 1228 1229 decoder := json.NewDecoder(body) 1230 decoder.UseNumber() 1231 var shape interface{} 1232 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1233 var snapshot bytes.Buffer 1234 io.Copy(&snapshot, ringBuffer) 1235 err = &smithy.DeserializationError{ 1236 Err: fmt.Errorf("failed to decode response body, %w", err), 1237 Snapshot: snapshot.Bytes(), 1238 } 1239 return out, metadata, err 1240 } 1241 1242 err = awsRestjson1_deserializeOpDocumentGetChannelOutput(&output, shape) 1243 if err != nil { 1244 var snapshot bytes.Buffer 1245 io.Copy(&snapshot, ringBuffer) 1246 return out, metadata, &smithy.DeserializationError{ 1247 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1248 Snapshot: snapshot.Bytes(), 1249 } 1250 } 1251 1252 return out, metadata, err 1253} 1254 1255func awsRestjson1_deserializeOpErrorGetChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1256 var errorBuffer bytes.Buffer 1257 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1258 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1259 } 1260 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1261 1262 errorCode := "UnknownError" 1263 errorMessage := errorCode 1264 1265 code := response.Header.Get("X-Amzn-ErrorType") 1266 if len(code) != 0 { 1267 errorCode = restjson.SanitizeErrorCode(code) 1268 } 1269 1270 var buff [1024]byte 1271 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1272 1273 body := io.TeeReader(errorBody, ringBuffer) 1274 decoder := json.NewDecoder(body) 1275 decoder.UseNumber() 1276 code, message, err := restjson.GetErrorInfo(decoder) 1277 if err != nil { 1278 var snapshot bytes.Buffer 1279 io.Copy(&snapshot, ringBuffer) 1280 err = &smithy.DeserializationError{ 1281 Err: fmt.Errorf("failed to decode response body, %w", err), 1282 Snapshot: snapshot.Bytes(), 1283 } 1284 return err 1285 } 1286 1287 errorBody.Seek(0, io.SeekStart) 1288 if len(code) != 0 { 1289 errorCode = restjson.SanitizeErrorCode(code) 1290 } 1291 if len(message) != 0 { 1292 errorMessage = message 1293 } 1294 1295 switch { 1296 case strings.EqualFold("AccessDeniedException", errorCode): 1297 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1298 1299 case strings.EqualFold("ResourceNotFoundException", errorCode): 1300 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1301 1302 case strings.EqualFold("ValidationException", errorCode): 1303 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1304 1305 default: 1306 genericError := &smithy.GenericAPIError{ 1307 Code: errorCode, 1308 Message: errorMessage, 1309 } 1310 return genericError 1311 1312 } 1313} 1314 1315func awsRestjson1_deserializeOpDocumentGetChannelOutput(v **GetChannelOutput, value interface{}) error { 1316 if v == nil { 1317 return fmt.Errorf("unexpected nil of type %T", v) 1318 } 1319 if value == nil { 1320 return nil 1321 } 1322 1323 shape, ok := value.(map[string]interface{}) 1324 if !ok { 1325 return fmt.Errorf("unexpected JSON type %v", value) 1326 } 1327 1328 var sv *GetChannelOutput 1329 if *v == nil { 1330 sv = &GetChannelOutput{} 1331 } else { 1332 sv = *v 1333 } 1334 1335 for key, value := range shape { 1336 switch key { 1337 case "channel": 1338 if err := awsRestjson1_deserializeDocumentChannel(&sv.Channel, value); err != nil { 1339 return err 1340 } 1341 1342 default: 1343 _, _ = key, value 1344 1345 } 1346 } 1347 *v = sv 1348 return nil 1349} 1350 1351type awsRestjson1_deserializeOpGetPlaybackKeyPair struct { 1352} 1353 1354func (*awsRestjson1_deserializeOpGetPlaybackKeyPair) ID() string { 1355 return "OperationDeserializer" 1356} 1357 1358func (m *awsRestjson1_deserializeOpGetPlaybackKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1359 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1360) { 1361 out, metadata, err = next.HandleDeserialize(ctx, in) 1362 if err != nil { 1363 return out, metadata, err 1364 } 1365 1366 response, ok := out.RawResponse.(*smithyhttp.Response) 1367 if !ok { 1368 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1369 } 1370 1371 if response.StatusCode < 200 || response.StatusCode >= 300 { 1372 return out, metadata, awsRestjson1_deserializeOpErrorGetPlaybackKeyPair(response, &metadata) 1373 } 1374 output := &GetPlaybackKeyPairOutput{} 1375 out.Result = output 1376 1377 var buff [1024]byte 1378 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1379 1380 body := io.TeeReader(response.Body, ringBuffer) 1381 1382 decoder := json.NewDecoder(body) 1383 decoder.UseNumber() 1384 var shape interface{} 1385 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1386 var snapshot bytes.Buffer 1387 io.Copy(&snapshot, ringBuffer) 1388 err = &smithy.DeserializationError{ 1389 Err: fmt.Errorf("failed to decode response body, %w", err), 1390 Snapshot: snapshot.Bytes(), 1391 } 1392 return out, metadata, err 1393 } 1394 1395 err = awsRestjson1_deserializeOpDocumentGetPlaybackKeyPairOutput(&output, shape) 1396 if err != nil { 1397 var snapshot bytes.Buffer 1398 io.Copy(&snapshot, ringBuffer) 1399 return out, metadata, &smithy.DeserializationError{ 1400 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1401 Snapshot: snapshot.Bytes(), 1402 } 1403 } 1404 1405 return out, metadata, err 1406} 1407 1408func awsRestjson1_deserializeOpErrorGetPlaybackKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1409 var errorBuffer bytes.Buffer 1410 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1411 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1412 } 1413 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1414 1415 errorCode := "UnknownError" 1416 errorMessage := errorCode 1417 1418 code := response.Header.Get("X-Amzn-ErrorType") 1419 if len(code) != 0 { 1420 errorCode = restjson.SanitizeErrorCode(code) 1421 } 1422 1423 var buff [1024]byte 1424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1425 1426 body := io.TeeReader(errorBody, ringBuffer) 1427 decoder := json.NewDecoder(body) 1428 decoder.UseNumber() 1429 code, message, err := restjson.GetErrorInfo(decoder) 1430 if err != nil { 1431 var snapshot bytes.Buffer 1432 io.Copy(&snapshot, ringBuffer) 1433 err = &smithy.DeserializationError{ 1434 Err: fmt.Errorf("failed to decode response body, %w", err), 1435 Snapshot: snapshot.Bytes(), 1436 } 1437 return err 1438 } 1439 1440 errorBody.Seek(0, io.SeekStart) 1441 if len(code) != 0 { 1442 errorCode = restjson.SanitizeErrorCode(code) 1443 } 1444 if len(message) != 0 { 1445 errorMessage = message 1446 } 1447 1448 switch { 1449 case strings.EqualFold("AccessDeniedException", errorCode): 1450 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1451 1452 case strings.EqualFold("ResourceNotFoundException", errorCode): 1453 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1454 1455 case strings.EqualFold("ValidationException", errorCode): 1456 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1457 1458 default: 1459 genericError := &smithy.GenericAPIError{ 1460 Code: errorCode, 1461 Message: errorMessage, 1462 } 1463 return genericError 1464 1465 } 1466} 1467 1468func awsRestjson1_deserializeOpDocumentGetPlaybackKeyPairOutput(v **GetPlaybackKeyPairOutput, value interface{}) error { 1469 if v == nil { 1470 return fmt.Errorf("unexpected nil of type %T", v) 1471 } 1472 if value == nil { 1473 return nil 1474 } 1475 1476 shape, ok := value.(map[string]interface{}) 1477 if !ok { 1478 return fmt.Errorf("unexpected JSON type %v", value) 1479 } 1480 1481 var sv *GetPlaybackKeyPairOutput 1482 if *v == nil { 1483 sv = &GetPlaybackKeyPairOutput{} 1484 } else { 1485 sv = *v 1486 } 1487 1488 for key, value := range shape { 1489 switch key { 1490 case "keyPair": 1491 if err := awsRestjson1_deserializeDocumentPlaybackKeyPair(&sv.KeyPair, value); err != nil { 1492 return err 1493 } 1494 1495 default: 1496 _, _ = key, value 1497 1498 } 1499 } 1500 *v = sv 1501 return nil 1502} 1503 1504type awsRestjson1_deserializeOpGetRecordingConfiguration struct { 1505} 1506 1507func (*awsRestjson1_deserializeOpGetRecordingConfiguration) ID() string { 1508 return "OperationDeserializer" 1509} 1510 1511func (m *awsRestjson1_deserializeOpGetRecordingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1512 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1513) { 1514 out, metadata, err = next.HandleDeserialize(ctx, in) 1515 if err != nil { 1516 return out, metadata, err 1517 } 1518 1519 response, ok := out.RawResponse.(*smithyhttp.Response) 1520 if !ok { 1521 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1522 } 1523 1524 if response.StatusCode < 200 || response.StatusCode >= 300 { 1525 return out, metadata, awsRestjson1_deserializeOpErrorGetRecordingConfiguration(response, &metadata) 1526 } 1527 output := &GetRecordingConfigurationOutput{} 1528 out.Result = output 1529 1530 var buff [1024]byte 1531 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1532 1533 body := io.TeeReader(response.Body, ringBuffer) 1534 1535 decoder := json.NewDecoder(body) 1536 decoder.UseNumber() 1537 var shape interface{} 1538 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1539 var snapshot bytes.Buffer 1540 io.Copy(&snapshot, ringBuffer) 1541 err = &smithy.DeserializationError{ 1542 Err: fmt.Errorf("failed to decode response body, %w", err), 1543 Snapshot: snapshot.Bytes(), 1544 } 1545 return out, metadata, err 1546 } 1547 1548 err = awsRestjson1_deserializeOpDocumentGetRecordingConfigurationOutput(&output, shape) 1549 if err != nil { 1550 var snapshot bytes.Buffer 1551 io.Copy(&snapshot, ringBuffer) 1552 return out, metadata, &smithy.DeserializationError{ 1553 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1554 Snapshot: snapshot.Bytes(), 1555 } 1556 } 1557 1558 return out, metadata, err 1559} 1560 1561func awsRestjson1_deserializeOpErrorGetRecordingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1562 var errorBuffer bytes.Buffer 1563 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1564 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1565 } 1566 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1567 1568 errorCode := "UnknownError" 1569 errorMessage := errorCode 1570 1571 code := response.Header.Get("X-Amzn-ErrorType") 1572 if len(code) != 0 { 1573 errorCode = restjson.SanitizeErrorCode(code) 1574 } 1575 1576 var buff [1024]byte 1577 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1578 1579 body := io.TeeReader(errorBody, ringBuffer) 1580 decoder := json.NewDecoder(body) 1581 decoder.UseNumber() 1582 code, message, err := restjson.GetErrorInfo(decoder) 1583 if err != nil { 1584 var snapshot bytes.Buffer 1585 io.Copy(&snapshot, ringBuffer) 1586 err = &smithy.DeserializationError{ 1587 Err: fmt.Errorf("failed to decode response body, %w", err), 1588 Snapshot: snapshot.Bytes(), 1589 } 1590 return err 1591 } 1592 1593 errorBody.Seek(0, io.SeekStart) 1594 if len(code) != 0 { 1595 errorCode = restjson.SanitizeErrorCode(code) 1596 } 1597 if len(message) != 0 { 1598 errorMessage = message 1599 } 1600 1601 switch { 1602 case strings.EqualFold("AccessDeniedException", errorCode): 1603 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1604 1605 case strings.EqualFold("InternalServerException", errorCode): 1606 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1607 1608 case strings.EqualFold("ResourceNotFoundException", errorCode): 1609 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1610 1611 case strings.EqualFold("ValidationException", errorCode): 1612 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1613 1614 default: 1615 genericError := &smithy.GenericAPIError{ 1616 Code: errorCode, 1617 Message: errorMessage, 1618 } 1619 return genericError 1620 1621 } 1622} 1623 1624func awsRestjson1_deserializeOpDocumentGetRecordingConfigurationOutput(v **GetRecordingConfigurationOutput, value interface{}) error { 1625 if v == nil { 1626 return fmt.Errorf("unexpected nil of type %T", v) 1627 } 1628 if value == nil { 1629 return nil 1630 } 1631 1632 shape, ok := value.(map[string]interface{}) 1633 if !ok { 1634 return fmt.Errorf("unexpected JSON type %v", value) 1635 } 1636 1637 var sv *GetRecordingConfigurationOutput 1638 if *v == nil { 1639 sv = &GetRecordingConfigurationOutput{} 1640 } else { 1641 sv = *v 1642 } 1643 1644 for key, value := range shape { 1645 switch key { 1646 case "recordingConfiguration": 1647 if err := awsRestjson1_deserializeDocumentRecordingConfiguration(&sv.RecordingConfiguration, value); err != nil { 1648 return err 1649 } 1650 1651 default: 1652 _, _ = key, value 1653 1654 } 1655 } 1656 *v = sv 1657 return nil 1658} 1659 1660type awsRestjson1_deserializeOpGetStream struct { 1661} 1662 1663func (*awsRestjson1_deserializeOpGetStream) ID() string { 1664 return "OperationDeserializer" 1665} 1666 1667func (m *awsRestjson1_deserializeOpGetStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1668 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1669) { 1670 out, metadata, err = next.HandleDeserialize(ctx, in) 1671 if err != nil { 1672 return out, metadata, err 1673 } 1674 1675 response, ok := out.RawResponse.(*smithyhttp.Response) 1676 if !ok { 1677 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1678 } 1679 1680 if response.StatusCode < 200 || response.StatusCode >= 300 { 1681 return out, metadata, awsRestjson1_deserializeOpErrorGetStream(response, &metadata) 1682 } 1683 output := &GetStreamOutput{} 1684 out.Result = output 1685 1686 var buff [1024]byte 1687 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1688 1689 body := io.TeeReader(response.Body, ringBuffer) 1690 1691 decoder := json.NewDecoder(body) 1692 decoder.UseNumber() 1693 var shape interface{} 1694 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1695 var snapshot bytes.Buffer 1696 io.Copy(&snapshot, ringBuffer) 1697 err = &smithy.DeserializationError{ 1698 Err: fmt.Errorf("failed to decode response body, %w", err), 1699 Snapshot: snapshot.Bytes(), 1700 } 1701 return out, metadata, err 1702 } 1703 1704 err = awsRestjson1_deserializeOpDocumentGetStreamOutput(&output, shape) 1705 if err != nil { 1706 var snapshot bytes.Buffer 1707 io.Copy(&snapshot, ringBuffer) 1708 return out, metadata, &smithy.DeserializationError{ 1709 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1710 Snapshot: snapshot.Bytes(), 1711 } 1712 } 1713 1714 return out, metadata, err 1715} 1716 1717func awsRestjson1_deserializeOpErrorGetStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1718 var errorBuffer bytes.Buffer 1719 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1720 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1721 } 1722 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1723 1724 errorCode := "UnknownError" 1725 errorMessage := errorCode 1726 1727 code := response.Header.Get("X-Amzn-ErrorType") 1728 if len(code) != 0 { 1729 errorCode = restjson.SanitizeErrorCode(code) 1730 } 1731 1732 var buff [1024]byte 1733 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1734 1735 body := io.TeeReader(errorBody, ringBuffer) 1736 decoder := json.NewDecoder(body) 1737 decoder.UseNumber() 1738 code, message, err := restjson.GetErrorInfo(decoder) 1739 if err != nil { 1740 var snapshot bytes.Buffer 1741 io.Copy(&snapshot, ringBuffer) 1742 err = &smithy.DeserializationError{ 1743 Err: fmt.Errorf("failed to decode response body, %w", err), 1744 Snapshot: snapshot.Bytes(), 1745 } 1746 return err 1747 } 1748 1749 errorBody.Seek(0, io.SeekStart) 1750 if len(code) != 0 { 1751 errorCode = restjson.SanitizeErrorCode(code) 1752 } 1753 if len(message) != 0 { 1754 errorMessage = message 1755 } 1756 1757 switch { 1758 case strings.EqualFold("AccessDeniedException", errorCode): 1759 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1760 1761 case strings.EqualFold("ChannelNotBroadcasting", errorCode): 1762 return awsRestjson1_deserializeErrorChannelNotBroadcasting(response, errorBody) 1763 1764 case strings.EqualFold("ResourceNotFoundException", errorCode): 1765 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1766 1767 case strings.EqualFold("ValidationException", errorCode): 1768 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1769 1770 default: 1771 genericError := &smithy.GenericAPIError{ 1772 Code: errorCode, 1773 Message: errorMessage, 1774 } 1775 return genericError 1776 1777 } 1778} 1779 1780func awsRestjson1_deserializeOpDocumentGetStreamOutput(v **GetStreamOutput, value interface{}) error { 1781 if v == nil { 1782 return fmt.Errorf("unexpected nil of type %T", v) 1783 } 1784 if value == nil { 1785 return nil 1786 } 1787 1788 shape, ok := value.(map[string]interface{}) 1789 if !ok { 1790 return fmt.Errorf("unexpected JSON type %v", value) 1791 } 1792 1793 var sv *GetStreamOutput 1794 if *v == nil { 1795 sv = &GetStreamOutput{} 1796 } else { 1797 sv = *v 1798 } 1799 1800 for key, value := range shape { 1801 switch key { 1802 case "stream": 1803 if err := awsRestjson1_deserializeDocumentStream(&sv.Stream, value); err != nil { 1804 return err 1805 } 1806 1807 default: 1808 _, _ = key, value 1809 1810 } 1811 } 1812 *v = sv 1813 return nil 1814} 1815 1816type awsRestjson1_deserializeOpGetStreamKey struct { 1817} 1818 1819func (*awsRestjson1_deserializeOpGetStreamKey) ID() string { 1820 return "OperationDeserializer" 1821} 1822 1823func (m *awsRestjson1_deserializeOpGetStreamKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1824 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1825) { 1826 out, metadata, err = next.HandleDeserialize(ctx, in) 1827 if err != nil { 1828 return out, metadata, err 1829 } 1830 1831 response, ok := out.RawResponse.(*smithyhttp.Response) 1832 if !ok { 1833 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1834 } 1835 1836 if response.StatusCode < 200 || response.StatusCode >= 300 { 1837 return out, metadata, awsRestjson1_deserializeOpErrorGetStreamKey(response, &metadata) 1838 } 1839 output := &GetStreamKeyOutput{} 1840 out.Result = output 1841 1842 var buff [1024]byte 1843 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1844 1845 body := io.TeeReader(response.Body, ringBuffer) 1846 1847 decoder := json.NewDecoder(body) 1848 decoder.UseNumber() 1849 var shape interface{} 1850 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1851 var snapshot bytes.Buffer 1852 io.Copy(&snapshot, ringBuffer) 1853 err = &smithy.DeserializationError{ 1854 Err: fmt.Errorf("failed to decode response body, %w", err), 1855 Snapshot: snapshot.Bytes(), 1856 } 1857 return out, metadata, err 1858 } 1859 1860 err = awsRestjson1_deserializeOpDocumentGetStreamKeyOutput(&output, shape) 1861 if err != nil { 1862 var snapshot bytes.Buffer 1863 io.Copy(&snapshot, ringBuffer) 1864 return out, metadata, &smithy.DeserializationError{ 1865 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1866 Snapshot: snapshot.Bytes(), 1867 } 1868 } 1869 1870 return out, metadata, err 1871} 1872 1873func awsRestjson1_deserializeOpErrorGetStreamKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1874 var errorBuffer bytes.Buffer 1875 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1876 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1877 } 1878 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1879 1880 errorCode := "UnknownError" 1881 errorMessage := errorCode 1882 1883 code := response.Header.Get("X-Amzn-ErrorType") 1884 if len(code) != 0 { 1885 errorCode = restjson.SanitizeErrorCode(code) 1886 } 1887 1888 var buff [1024]byte 1889 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1890 1891 body := io.TeeReader(errorBody, ringBuffer) 1892 decoder := json.NewDecoder(body) 1893 decoder.UseNumber() 1894 code, message, err := restjson.GetErrorInfo(decoder) 1895 if err != nil { 1896 var snapshot bytes.Buffer 1897 io.Copy(&snapshot, ringBuffer) 1898 err = &smithy.DeserializationError{ 1899 Err: fmt.Errorf("failed to decode response body, %w", err), 1900 Snapshot: snapshot.Bytes(), 1901 } 1902 return err 1903 } 1904 1905 errorBody.Seek(0, io.SeekStart) 1906 if len(code) != 0 { 1907 errorCode = restjson.SanitizeErrorCode(code) 1908 } 1909 if len(message) != 0 { 1910 errorMessage = message 1911 } 1912 1913 switch { 1914 case strings.EqualFold("AccessDeniedException", errorCode): 1915 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1916 1917 case strings.EqualFold("ResourceNotFoundException", errorCode): 1918 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1919 1920 case strings.EqualFold("ValidationException", errorCode): 1921 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1922 1923 default: 1924 genericError := &smithy.GenericAPIError{ 1925 Code: errorCode, 1926 Message: errorMessage, 1927 } 1928 return genericError 1929 1930 } 1931} 1932 1933func awsRestjson1_deserializeOpDocumentGetStreamKeyOutput(v **GetStreamKeyOutput, value interface{}) error { 1934 if v == nil { 1935 return fmt.Errorf("unexpected nil of type %T", v) 1936 } 1937 if value == nil { 1938 return nil 1939 } 1940 1941 shape, ok := value.(map[string]interface{}) 1942 if !ok { 1943 return fmt.Errorf("unexpected JSON type %v", value) 1944 } 1945 1946 var sv *GetStreamKeyOutput 1947 if *v == nil { 1948 sv = &GetStreamKeyOutput{} 1949 } else { 1950 sv = *v 1951 } 1952 1953 for key, value := range shape { 1954 switch key { 1955 case "streamKey": 1956 if err := awsRestjson1_deserializeDocumentStreamKey(&sv.StreamKey, value); err != nil { 1957 return err 1958 } 1959 1960 default: 1961 _, _ = key, value 1962 1963 } 1964 } 1965 *v = sv 1966 return nil 1967} 1968 1969type awsRestjson1_deserializeOpImportPlaybackKeyPair struct { 1970} 1971 1972func (*awsRestjson1_deserializeOpImportPlaybackKeyPair) ID() string { 1973 return "OperationDeserializer" 1974} 1975 1976func (m *awsRestjson1_deserializeOpImportPlaybackKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1977 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1978) { 1979 out, metadata, err = next.HandleDeserialize(ctx, in) 1980 if err != nil { 1981 return out, metadata, err 1982 } 1983 1984 response, ok := out.RawResponse.(*smithyhttp.Response) 1985 if !ok { 1986 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1987 } 1988 1989 if response.StatusCode < 200 || response.StatusCode >= 300 { 1990 return out, metadata, awsRestjson1_deserializeOpErrorImportPlaybackKeyPair(response, &metadata) 1991 } 1992 output := &ImportPlaybackKeyPairOutput{} 1993 out.Result = output 1994 1995 var buff [1024]byte 1996 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1997 1998 body := io.TeeReader(response.Body, ringBuffer) 1999 2000 decoder := json.NewDecoder(body) 2001 decoder.UseNumber() 2002 var shape interface{} 2003 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2004 var snapshot bytes.Buffer 2005 io.Copy(&snapshot, ringBuffer) 2006 err = &smithy.DeserializationError{ 2007 Err: fmt.Errorf("failed to decode response body, %w", err), 2008 Snapshot: snapshot.Bytes(), 2009 } 2010 return out, metadata, err 2011 } 2012 2013 err = awsRestjson1_deserializeOpDocumentImportPlaybackKeyPairOutput(&output, shape) 2014 if err != nil { 2015 var snapshot bytes.Buffer 2016 io.Copy(&snapshot, ringBuffer) 2017 return out, metadata, &smithy.DeserializationError{ 2018 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2019 Snapshot: snapshot.Bytes(), 2020 } 2021 } 2022 2023 return out, metadata, err 2024} 2025 2026func awsRestjson1_deserializeOpErrorImportPlaybackKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2027 var errorBuffer bytes.Buffer 2028 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2029 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2030 } 2031 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2032 2033 errorCode := "UnknownError" 2034 errorMessage := errorCode 2035 2036 code := response.Header.Get("X-Amzn-ErrorType") 2037 if len(code) != 0 { 2038 errorCode = restjson.SanitizeErrorCode(code) 2039 } 2040 2041 var buff [1024]byte 2042 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2043 2044 body := io.TeeReader(errorBody, ringBuffer) 2045 decoder := json.NewDecoder(body) 2046 decoder.UseNumber() 2047 code, message, err := restjson.GetErrorInfo(decoder) 2048 if err != nil { 2049 var snapshot bytes.Buffer 2050 io.Copy(&snapshot, ringBuffer) 2051 err = &smithy.DeserializationError{ 2052 Err: fmt.Errorf("failed to decode response body, %w", err), 2053 Snapshot: snapshot.Bytes(), 2054 } 2055 return err 2056 } 2057 2058 errorBody.Seek(0, io.SeekStart) 2059 if len(code) != 0 { 2060 errorCode = restjson.SanitizeErrorCode(code) 2061 } 2062 if len(message) != 0 { 2063 errorMessage = message 2064 } 2065 2066 switch { 2067 case strings.EqualFold("AccessDeniedException", errorCode): 2068 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2069 2070 case strings.EqualFold("ConflictException", errorCode): 2071 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2072 2073 case strings.EqualFold("PendingVerification", errorCode): 2074 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 2075 2076 case strings.EqualFold("ServiceQuotaExceededException", errorCode): 2077 return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody) 2078 2079 case strings.EqualFold("ValidationException", errorCode): 2080 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2081 2082 default: 2083 genericError := &smithy.GenericAPIError{ 2084 Code: errorCode, 2085 Message: errorMessage, 2086 } 2087 return genericError 2088 2089 } 2090} 2091 2092func awsRestjson1_deserializeOpDocumentImportPlaybackKeyPairOutput(v **ImportPlaybackKeyPairOutput, value interface{}) error { 2093 if v == nil { 2094 return fmt.Errorf("unexpected nil of type %T", v) 2095 } 2096 if value == nil { 2097 return nil 2098 } 2099 2100 shape, ok := value.(map[string]interface{}) 2101 if !ok { 2102 return fmt.Errorf("unexpected JSON type %v", value) 2103 } 2104 2105 var sv *ImportPlaybackKeyPairOutput 2106 if *v == nil { 2107 sv = &ImportPlaybackKeyPairOutput{} 2108 } else { 2109 sv = *v 2110 } 2111 2112 for key, value := range shape { 2113 switch key { 2114 case "keyPair": 2115 if err := awsRestjson1_deserializeDocumentPlaybackKeyPair(&sv.KeyPair, value); err != nil { 2116 return err 2117 } 2118 2119 default: 2120 _, _ = key, value 2121 2122 } 2123 } 2124 *v = sv 2125 return nil 2126} 2127 2128type awsRestjson1_deserializeOpListChannels struct { 2129} 2130 2131func (*awsRestjson1_deserializeOpListChannels) ID() string { 2132 return "OperationDeserializer" 2133} 2134 2135func (m *awsRestjson1_deserializeOpListChannels) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2136 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2137) { 2138 out, metadata, err = next.HandleDeserialize(ctx, in) 2139 if err != nil { 2140 return out, metadata, err 2141 } 2142 2143 response, ok := out.RawResponse.(*smithyhttp.Response) 2144 if !ok { 2145 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2146 } 2147 2148 if response.StatusCode < 200 || response.StatusCode >= 300 { 2149 return out, metadata, awsRestjson1_deserializeOpErrorListChannels(response, &metadata) 2150 } 2151 output := &ListChannelsOutput{} 2152 out.Result = output 2153 2154 var buff [1024]byte 2155 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2156 2157 body := io.TeeReader(response.Body, ringBuffer) 2158 2159 decoder := json.NewDecoder(body) 2160 decoder.UseNumber() 2161 var shape interface{} 2162 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2163 var snapshot bytes.Buffer 2164 io.Copy(&snapshot, ringBuffer) 2165 err = &smithy.DeserializationError{ 2166 Err: fmt.Errorf("failed to decode response body, %w", err), 2167 Snapshot: snapshot.Bytes(), 2168 } 2169 return out, metadata, err 2170 } 2171 2172 err = awsRestjson1_deserializeOpDocumentListChannelsOutput(&output, shape) 2173 if err != nil { 2174 var snapshot bytes.Buffer 2175 io.Copy(&snapshot, ringBuffer) 2176 return out, metadata, &smithy.DeserializationError{ 2177 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2178 Snapshot: snapshot.Bytes(), 2179 } 2180 } 2181 2182 return out, metadata, err 2183} 2184 2185func awsRestjson1_deserializeOpErrorListChannels(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2186 var errorBuffer bytes.Buffer 2187 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2188 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2189 } 2190 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2191 2192 errorCode := "UnknownError" 2193 errorMessage := errorCode 2194 2195 code := response.Header.Get("X-Amzn-ErrorType") 2196 if len(code) != 0 { 2197 errorCode = restjson.SanitizeErrorCode(code) 2198 } 2199 2200 var buff [1024]byte 2201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2202 2203 body := io.TeeReader(errorBody, ringBuffer) 2204 decoder := json.NewDecoder(body) 2205 decoder.UseNumber() 2206 code, message, err := restjson.GetErrorInfo(decoder) 2207 if err != nil { 2208 var snapshot bytes.Buffer 2209 io.Copy(&snapshot, ringBuffer) 2210 err = &smithy.DeserializationError{ 2211 Err: fmt.Errorf("failed to decode response body, %w", err), 2212 Snapshot: snapshot.Bytes(), 2213 } 2214 return err 2215 } 2216 2217 errorBody.Seek(0, io.SeekStart) 2218 if len(code) != 0 { 2219 errorCode = restjson.SanitizeErrorCode(code) 2220 } 2221 if len(message) != 0 { 2222 errorMessage = message 2223 } 2224 2225 switch { 2226 case strings.EqualFold("AccessDeniedException", errorCode): 2227 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2228 2229 case strings.EqualFold("ConflictException", errorCode): 2230 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2231 2232 case strings.EqualFold("ValidationException", errorCode): 2233 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2234 2235 default: 2236 genericError := &smithy.GenericAPIError{ 2237 Code: errorCode, 2238 Message: errorMessage, 2239 } 2240 return genericError 2241 2242 } 2243} 2244 2245func awsRestjson1_deserializeOpDocumentListChannelsOutput(v **ListChannelsOutput, value interface{}) error { 2246 if v == nil { 2247 return fmt.Errorf("unexpected nil of type %T", v) 2248 } 2249 if value == nil { 2250 return nil 2251 } 2252 2253 shape, ok := value.(map[string]interface{}) 2254 if !ok { 2255 return fmt.Errorf("unexpected JSON type %v", value) 2256 } 2257 2258 var sv *ListChannelsOutput 2259 if *v == nil { 2260 sv = &ListChannelsOutput{} 2261 } else { 2262 sv = *v 2263 } 2264 2265 for key, value := range shape { 2266 switch key { 2267 case "channels": 2268 if err := awsRestjson1_deserializeDocumentChannelList(&sv.Channels, value); err != nil { 2269 return err 2270 } 2271 2272 case "nextToken": 2273 if value != nil { 2274 jtv, ok := value.(string) 2275 if !ok { 2276 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2277 } 2278 sv.NextToken = ptr.String(jtv) 2279 } 2280 2281 default: 2282 _, _ = key, value 2283 2284 } 2285 } 2286 *v = sv 2287 return nil 2288} 2289 2290type awsRestjson1_deserializeOpListPlaybackKeyPairs struct { 2291} 2292 2293func (*awsRestjson1_deserializeOpListPlaybackKeyPairs) ID() string { 2294 return "OperationDeserializer" 2295} 2296 2297func (m *awsRestjson1_deserializeOpListPlaybackKeyPairs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2298 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2299) { 2300 out, metadata, err = next.HandleDeserialize(ctx, in) 2301 if err != nil { 2302 return out, metadata, err 2303 } 2304 2305 response, ok := out.RawResponse.(*smithyhttp.Response) 2306 if !ok { 2307 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2308 } 2309 2310 if response.StatusCode < 200 || response.StatusCode >= 300 { 2311 return out, metadata, awsRestjson1_deserializeOpErrorListPlaybackKeyPairs(response, &metadata) 2312 } 2313 output := &ListPlaybackKeyPairsOutput{} 2314 out.Result = output 2315 2316 var buff [1024]byte 2317 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2318 2319 body := io.TeeReader(response.Body, ringBuffer) 2320 2321 decoder := json.NewDecoder(body) 2322 decoder.UseNumber() 2323 var shape interface{} 2324 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2325 var snapshot bytes.Buffer 2326 io.Copy(&snapshot, ringBuffer) 2327 err = &smithy.DeserializationError{ 2328 Err: fmt.Errorf("failed to decode response body, %w", err), 2329 Snapshot: snapshot.Bytes(), 2330 } 2331 return out, metadata, err 2332 } 2333 2334 err = awsRestjson1_deserializeOpDocumentListPlaybackKeyPairsOutput(&output, shape) 2335 if err != nil { 2336 var snapshot bytes.Buffer 2337 io.Copy(&snapshot, ringBuffer) 2338 return out, metadata, &smithy.DeserializationError{ 2339 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2340 Snapshot: snapshot.Bytes(), 2341 } 2342 } 2343 2344 return out, metadata, err 2345} 2346 2347func awsRestjson1_deserializeOpErrorListPlaybackKeyPairs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2348 var errorBuffer bytes.Buffer 2349 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2350 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2351 } 2352 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2353 2354 errorCode := "UnknownError" 2355 errorMessage := errorCode 2356 2357 code := response.Header.Get("X-Amzn-ErrorType") 2358 if len(code) != 0 { 2359 errorCode = restjson.SanitizeErrorCode(code) 2360 } 2361 2362 var buff [1024]byte 2363 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2364 2365 body := io.TeeReader(errorBody, ringBuffer) 2366 decoder := json.NewDecoder(body) 2367 decoder.UseNumber() 2368 code, message, err := restjson.GetErrorInfo(decoder) 2369 if err != nil { 2370 var snapshot bytes.Buffer 2371 io.Copy(&snapshot, ringBuffer) 2372 err = &smithy.DeserializationError{ 2373 Err: fmt.Errorf("failed to decode response body, %w", err), 2374 Snapshot: snapshot.Bytes(), 2375 } 2376 return err 2377 } 2378 2379 errorBody.Seek(0, io.SeekStart) 2380 if len(code) != 0 { 2381 errorCode = restjson.SanitizeErrorCode(code) 2382 } 2383 if len(message) != 0 { 2384 errorMessage = message 2385 } 2386 2387 switch { 2388 case strings.EqualFold("AccessDeniedException", errorCode): 2389 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2390 2391 case strings.EqualFold("ValidationException", errorCode): 2392 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2393 2394 default: 2395 genericError := &smithy.GenericAPIError{ 2396 Code: errorCode, 2397 Message: errorMessage, 2398 } 2399 return genericError 2400 2401 } 2402} 2403 2404func awsRestjson1_deserializeOpDocumentListPlaybackKeyPairsOutput(v **ListPlaybackKeyPairsOutput, value interface{}) error { 2405 if v == nil { 2406 return fmt.Errorf("unexpected nil of type %T", v) 2407 } 2408 if value == nil { 2409 return nil 2410 } 2411 2412 shape, ok := value.(map[string]interface{}) 2413 if !ok { 2414 return fmt.Errorf("unexpected JSON type %v", value) 2415 } 2416 2417 var sv *ListPlaybackKeyPairsOutput 2418 if *v == nil { 2419 sv = &ListPlaybackKeyPairsOutput{} 2420 } else { 2421 sv = *v 2422 } 2423 2424 for key, value := range shape { 2425 switch key { 2426 case "keyPairs": 2427 if err := awsRestjson1_deserializeDocumentPlaybackKeyPairList(&sv.KeyPairs, value); err != nil { 2428 return err 2429 } 2430 2431 case "nextToken": 2432 if value != nil { 2433 jtv, ok := value.(string) 2434 if !ok { 2435 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2436 } 2437 sv.NextToken = ptr.String(jtv) 2438 } 2439 2440 default: 2441 _, _ = key, value 2442 2443 } 2444 } 2445 *v = sv 2446 return nil 2447} 2448 2449type awsRestjson1_deserializeOpListRecordingConfigurations struct { 2450} 2451 2452func (*awsRestjson1_deserializeOpListRecordingConfigurations) ID() string { 2453 return "OperationDeserializer" 2454} 2455 2456func (m *awsRestjson1_deserializeOpListRecordingConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2457 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2458) { 2459 out, metadata, err = next.HandleDeserialize(ctx, in) 2460 if err != nil { 2461 return out, metadata, err 2462 } 2463 2464 response, ok := out.RawResponse.(*smithyhttp.Response) 2465 if !ok { 2466 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2467 } 2468 2469 if response.StatusCode < 200 || response.StatusCode >= 300 { 2470 return out, metadata, awsRestjson1_deserializeOpErrorListRecordingConfigurations(response, &metadata) 2471 } 2472 output := &ListRecordingConfigurationsOutput{} 2473 out.Result = output 2474 2475 var buff [1024]byte 2476 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2477 2478 body := io.TeeReader(response.Body, ringBuffer) 2479 2480 decoder := json.NewDecoder(body) 2481 decoder.UseNumber() 2482 var shape interface{} 2483 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2484 var snapshot bytes.Buffer 2485 io.Copy(&snapshot, ringBuffer) 2486 err = &smithy.DeserializationError{ 2487 Err: fmt.Errorf("failed to decode response body, %w", err), 2488 Snapshot: snapshot.Bytes(), 2489 } 2490 return out, metadata, err 2491 } 2492 2493 err = awsRestjson1_deserializeOpDocumentListRecordingConfigurationsOutput(&output, shape) 2494 if err != nil { 2495 var snapshot bytes.Buffer 2496 io.Copy(&snapshot, ringBuffer) 2497 return out, metadata, &smithy.DeserializationError{ 2498 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2499 Snapshot: snapshot.Bytes(), 2500 } 2501 } 2502 2503 return out, metadata, err 2504} 2505 2506func awsRestjson1_deserializeOpErrorListRecordingConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2507 var errorBuffer bytes.Buffer 2508 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2509 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2510 } 2511 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2512 2513 errorCode := "UnknownError" 2514 errorMessage := errorCode 2515 2516 code := response.Header.Get("X-Amzn-ErrorType") 2517 if len(code) != 0 { 2518 errorCode = restjson.SanitizeErrorCode(code) 2519 } 2520 2521 var buff [1024]byte 2522 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2523 2524 body := io.TeeReader(errorBody, ringBuffer) 2525 decoder := json.NewDecoder(body) 2526 decoder.UseNumber() 2527 code, message, err := restjson.GetErrorInfo(decoder) 2528 if err != nil { 2529 var snapshot bytes.Buffer 2530 io.Copy(&snapshot, ringBuffer) 2531 err = &smithy.DeserializationError{ 2532 Err: fmt.Errorf("failed to decode response body, %w", err), 2533 Snapshot: snapshot.Bytes(), 2534 } 2535 return err 2536 } 2537 2538 errorBody.Seek(0, io.SeekStart) 2539 if len(code) != 0 { 2540 errorCode = restjson.SanitizeErrorCode(code) 2541 } 2542 if len(message) != 0 { 2543 errorMessage = message 2544 } 2545 2546 switch { 2547 case strings.EqualFold("AccessDeniedException", errorCode): 2548 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2549 2550 case strings.EqualFold("InternalServerException", errorCode): 2551 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 2552 2553 case strings.EqualFold("ValidationException", errorCode): 2554 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2555 2556 default: 2557 genericError := &smithy.GenericAPIError{ 2558 Code: errorCode, 2559 Message: errorMessage, 2560 } 2561 return genericError 2562 2563 } 2564} 2565 2566func awsRestjson1_deserializeOpDocumentListRecordingConfigurationsOutput(v **ListRecordingConfigurationsOutput, value interface{}) error { 2567 if v == nil { 2568 return fmt.Errorf("unexpected nil of type %T", v) 2569 } 2570 if value == nil { 2571 return nil 2572 } 2573 2574 shape, ok := value.(map[string]interface{}) 2575 if !ok { 2576 return fmt.Errorf("unexpected JSON type %v", value) 2577 } 2578 2579 var sv *ListRecordingConfigurationsOutput 2580 if *v == nil { 2581 sv = &ListRecordingConfigurationsOutput{} 2582 } else { 2583 sv = *v 2584 } 2585 2586 for key, value := range shape { 2587 switch key { 2588 case "nextToken": 2589 if value != nil { 2590 jtv, ok := value.(string) 2591 if !ok { 2592 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2593 } 2594 sv.NextToken = ptr.String(jtv) 2595 } 2596 2597 case "recordingConfigurations": 2598 if err := awsRestjson1_deserializeDocumentRecordingConfigurationList(&sv.RecordingConfigurations, value); err != nil { 2599 return err 2600 } 2601 2602 default: 2603 _, _ = key, value 2604 2605 } 2606 } 2607 *v = sv 2608 return nil 2609} 2610 2611type awsRestjson1_deserializeOpListStreamKeys struct { 2612} 2613 2614func (*awsRestjson1_deserializeOpListStreamKeys) ID() string { 2615 return "OperationDeserializer" 2616} 2617 2618func (m *awsRestjson1_deserializeOpListStreamKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2619 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2620) { 2621 out, metadata, err = next.HandleDeserialize(ctx, in) 2622 if err != nil { 2623 return out, metadata, err 2624 } 2625 2626 response, ok := out.RawResponse.(*smithyhttp.Response) 2627 if !ok { 2628 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2629 } 2630 2631 if response.StatusCode < 200 || response.StatusCode >= 300 { 2632 return out, metadata, awsRestjson1_deserializeOpErrorListStreamKeys(response, &metadata) 2633 } 2634 output := &ListStreamKeysOutput{} 2635 out.Result = output 2636 2637 var buff [1024]byte 2638 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2639 2640 body := io.TeeReader(response.Body, ringBuffer) 2641 2642 decoder := json.NewDecoder(body) 2643 decoder.UseNumber() 2644 var shape interface{} 2645 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2646 var snapshot bytes.Buffer 2647 io.Copy(&snapshot, ringBuffer) 2648 err = &smithy.DeserializationError{ 2649 Err: fmt.Errorf("failed to decode response body, %w", err), 2650 Snapshot: snapshot.Bytes(), 2651 } 2652 return out, metadata, err 2653 } 2654 2655 err = awsRestjson1_deserializeOpDocumentListStreamKeysOutput(&output, shape) 2656 if err != nil { 2657 var snapshot bytes.Buffer 2658 io.Copy(&snapshot, ringBuffer) 2659 return out, metadata, &smithy.DeserializationError{ 2660 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2661 Snapshot: snapshot.Bytes(), 2662 } 2663 } 2664 2665 return out, metadata, err 2666} 2667 2668func awsRestjson1_deserializeOpErrorListStreamKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2669 var errorBuffer bytes.Buffer 2670 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2671 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2672 } 2673 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2674 2675 errorCode := "UnknownError" 2676 errorMessage := errorCode 2677 2678 code := response.Header.Get("X-Amzn-ErrorType") 2679 if len(code) != 0 { 2680 errorCode = restjson.SanitizeErrorCode(code) 2681 } 2682 2683 var buff [1024]byte 2684 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2685 2686 body := io.TeeReader(errorBody, ringBuffer) 2687 decoder := json.NewDecoder(body) 2688 decoder.UseNumber() 2689 code, message, err := restjson.GetErrorInfo(decoder) 2690 if err != nil { 2691 var snapshot bytes.Buffer 2692 io.Copy(&snapshot, ringBuffer) 2693 err = &smithy.DeserializationError{ 2694 Err: fmt.Errorf("failed to decode response body, %w", err), 2695 Snapshot: snapshot.Bytes(), 2696 } 2697 return err 2698 } 2699 2700 errorBody.Seek(0, io.SeekStart) 2701 if len(code) != 0 { 2702 errorCode = restjson.SanitizeErrorCode(code) 2703 } 2704 if len(message) != 0 { 2705 errorMessage = message 2706 } 2707 2708 switch { 2709 case strings.EqualFold("AccessDeniedException", errorCode): 2710 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2711 2712 case strings.EqualFold("ResourceNotFoundException", errorCode): 2713 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2714 2715 case strings.EqualFold("ValidationException", errorCode): 2716 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2717 2718 default: 2719 genericError := &smithy.GenericAPIError{ 2720 Code: errorCode, 2721 Message: errorMessage, 2722 } 2723 return genericError 2724 2725 } 2726} 2727 2728func awsRestjson1_deserializeOpDocumentListStreamKeysOutput(v **ListStreamKeysOutput, value interface{}) error { 2729 if v == nil { 2730 return fmt.Errorf("unexpected nil of type %T", v) 2731 } 2732 if value == nil { 2733 return nil 2734 } 2735 2736 shape, ok := value.(map[string]interface{}) 2737 if !ok { 2738 return fmt.Errorf("unexpected JSON type %v", value) 2739 } 2740 2741 var sv *ListStreamKeysOutput 2742 if *v == nil { 2743 sv = &ListStreamKeysOutput{} 2744 } else { 2745 sv = *v 2746 } 2747 2748 for key, value := range shape { 2749 switch key { 2750 case "nextToken": 2751 if value != nil { 2752 jtv, ok := value.(string) 2753 if !ok { 2754 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2755 } 2756 sv.NextToken = ptr.String(jtv) 2757 } 2758 2759 case "streamKeys": 2760 if err := awsRestjson1_deserializeDocumentStreamKeyList(&sv.StreamKeys, value); err != nil { 2761 return err 2762 } 2763 2764 default: 2765 _, _ = key, value 2766 2767 } 2768 } 2769 *v = sv 2770 return nil 2771} 2772 2773type awsRestjson1_deserializeOpListStreams struct { 2774} 2775 2776func (*awsRestjson1_deserializeOpListStreams) ID() string { 2777 return "OperationDeserializer" 2778} 2779 2780func (m *awsRestjson1_deserializeOpListStreams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2781 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2782) { 2783 out, metadata, err = next.HandleDeserialize(ctx, in) 2784 if err != nil { 2785 return out, metadata, err 2786 } 2787 2788 response, ok := out.RawResponse.(*smithyhttp.Response) 2789 if !ok { 2790 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2791 } 2792 2793 if response.StatusCode < 200 || response.StatusCode >= 300 { 2794 return out, metadata, awsRestjson1_deserializeOpErrorListStreams(response, &metadata) 2795 } 2796 output := &ListStreamsOutput{} 2797 out.Result = output 2798 2799 var buff [1024]byte 2800 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2801 2802 body := io.TeeReader(response.Body, ringBuffer) 2803 2804 decoder := json.NewDecoder(body) 2805 decoder.UseNumber() 2806 var shape interface{} 2807 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2808 var snapshot bytes.Buffer 2809 io.Copy(&snapshot, ringBuffer) 2810 err = &smithy.DeserializationError{ 2811 Err: fmt.Errorf("failed to decode response body, %w", err), 2812 Snapshot: snapshot.Bytes(), 2813 } 2814 return out, metadata, err 2815 } 2816 2817 err = awsRestjson1_deserializeOpDocumentListStreamsOutput(&output, shape) 2818 if err != nil { 2819 var snapshot bytes.Buffer 2820 io.Copy(&snapshot, ringBuffer) 2821 return out, metadata, &smithy.DeserializationError{ 2822 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2823 Snapshot: snapshot.Bytes(), 2824 } 2825 } 2826 2827 return out, metadata, err 2828} 2829 2830func awsRestjson1_deserializeOpErrorListStreams(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2831 var errorBuffer bytes.Buffer 2832 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2833 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2834 } 2835 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2836 2837 errorCode := "UnknownError" 2838 errorMessage := errorCode 2839 2840 code := response.Header.Get("X-Amzn-ErrorType") 2841 if len(code) != 0 { 2842 errorCode = restjson.SanitizeErrorCode(code) 2843 } 2844 2845 var buff [1024]byte 2846 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2847 2848 body := io.TeeReader(errorBody, ringBuffer) 2849 decoder := json.NewDecoder(body) 2850 decoder.UseNumber() 2851 code, message, err := restjson.GetErrorInfo(decoder) 2852 if err != nil { 2853 var snapshot bytes.Buffer 2854 io.Copy(&snapshot, ringBuffer) 2855 err = &smithy.DeserializationError{ 2856 Err: fmt.Errorf("failed to decode response body, %w", err), 2857 Snapshot: snapshot.Bytes(), 2858 } 2859 return err 2860 } 2861 2862 errorBody.Seek(0, io.SeekStart) 2863 if len(code) != 0 { 2864 errorCode = restjson.SanitizeErrorCode(code) 2865 } 2866 if len(message) != 0 { 2867 errorMessage = message 2868 } 2869 2870 switch { 2871 case strings.EqualFold("AccessDeniedException", errorCode): 2872 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2873 2874 default: 2875 genericError := &smithy.GenericAPIError{ 2876 Code: errorCode, 2877 Message: errorMessage, 2878 } 2879 return genericError 2880 2881 } 2882} 2883 2884func awsRestjson1_deserializeOpDocumentListStreamsOutput(v **ListStreamsOutput, value interface{}) error { 2885 if v == nil { 2886 return fmt.Errorf("unexpected nil of type %T", v) 2887 } 2888 if value == nil { 2889 return nil 2890 } 2891 2892 shape, ok := value.(map[string]interface{}) 2893 if !ok { 2894 return fmt.Errorf("unexpected JSON type %v", value) 2895 } 2896 2897 var sv *ListStreamsOutput 2898 if *v == nil { 2899 sv = &ListStreamsOutput{} 2900 } else { 2901 sv = *v 2902 } 2903 2904 for key, value := range shape { 2905 switch key { 2906 case "nextToken": 2907 if value != nil { 2908 jtv, ok := value.(string) 2909 if !ok { 2910 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2911 } 2912 sv.NextToken = ptr.String(jtv) 2913 } 2914 2915 case "streams": 2916 if err := awsRestjson1_deserializeDocumentStreamList(&sv.Streams, value); err != nil { 2917 return err 2918 } 2919 2920 default: 2921 _, _ = key, value 2922 2923 } 2924 } 2925 *v = sv 2926 return nil 2927} 2928 2929type awsRestjson1_deserializeOpListTagsForResource struct { 2930} 2931 2932func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 2933 return "OperationDeserializer" 2934} 2935 2936func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2937 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2938) { 2939 out, metadata, err = next.HandleDeserialize(ctx, in) 2940 if err != nil { 2941 return out, metadata, err 2942 } 2943 2944 response, ok := out.RawResponse.(*smithyhttp.Response) 2945 if !ok { 2946 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2947 } 2948 2949 if response.StatusCode < 200 || response.StatusCode >= 300 { 2950 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 2951 } 2952 output := &ListTagsForResourceOutput{} 2953 out.Result = output 2954 2955 var buff [1024]byte 2956 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2957 2958 body := io.TeeReader(response.Body, ringBuffer) 2959 2960 decoder := json.NewDecoder(body) 2961 decoder.UseNumber() 2962 var shape interface{} 2963 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2964 var snapshot bytes.Buffer 2965 io.Copy(&snapshot, ringBuffer) 2966 err = &smithy.DeserializationError{ 2967 Err: fmt.Errorf("failed to decode response body, %w", err), 2968 Snapshot: snapshot.Bytes(), 2969 } 2970 return out, metadata, err 2971 } 2972 2973 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2974 if err != nil { 2975 var snapshot bytes.Buffer 2976 io.Copy(&snapshot, ringBuffer) 2977 return out, metadata, &smithy.DeserializationError{ 2978 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2979 Snapshot: snapshot.Bytes(), 2980 } 2981 } 2982 2983 return out, metadata, err 2984} 2985 2986func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2987 var errorBuffer bytes.Buffer 2988 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2989 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2990 } 2991 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2992 2993 errorCode := "UnknownError" 2994 errorMessage := errorCode 2995 2996 code := response.Header.Get("X-Amzn-ErrorType") 2997 if len(code) != 0 { 2998 errorCode = restjson.SanitizeErrorCode(code) 2999 } 3000 3001 var buff [1024]byte 3002 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3003 3004 body := io.TeeReader(errorBody, ringBuffer) 3005 decoder := json.NewDecoder(body) 3006 decoder.UseNumber() 3007 code, message, err := restjson.GetErrorInfo(decoder) 3008 if err != nil { 3009 var snapshot bytes.Buffer 3010 io.Copy(&snapshot, ringBuffer) 3011 err = &smithy.DeserializationError{ 3012 Err: fmt.Errorf("failed to decode response body, %w", err), 3013 Snapshot: snapshot.Bytes(), 3014 } 3015 return err 3016 } 3017 3018 errorBody.Seek(0, io.SeekStart) 3019 if len(code) != 0 { 3020 errorCode = restjson.SanitizeErrorCode(code) 3021 } 3022 if len(message) != 0 { 3023 errorMessage = message 3024 } 3025 3026 switch { 3027 case strings.EqualFold("InternalServerException", errorCode): 3028 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3029 3030 case strings.EqualFold("ResourceNotFoundException", errorCode): 3031 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3032 3033 case strings.EqualFold("ValidationException", errorCode): 3034 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3035 3036 default: 3037 genericError := &smithy.GenericAPIError{ 3038 Code: errorCode, 3039 Message: errorMessage, 3040 } 3041 return genericError 3042 3043 } 3044} 3045 3046func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 3047 if v == nil { 3048 return fmt.Errorf("unexpected nil of type %T", v) 3049 } 3050 if value == nil { 3051 return nil 3052 } 3053 3054 shape, ok := value.(map[string]interface{}) 3055 if !ok { 3056 return fmt.Errorf("unexpected JSON type %v", value) 3057 } 3058 3059 var sv *ListTagsForResourceOutput 3060 if *v == nil { 3061 sv = &ListTagsForResourceOutput{} 3062 } else { 3063 sv = *v 3064 } 3065 3066 for key, value := range shape { 3067 switch key { 3068 case "nextToken": 3069 if value != nil { 3070 jtv, ok := value.(string) 3071 if !ok { 3072 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3073 } 3074 sv.NextToken = ptr.String(jtv) 3075 } 3076 3077 case "tags": 3078 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 3079 return err 3080 } 3081 3082 default: 3083 _, _ = key, value 3084 3085 } 3086 } 3087 *v = sv 3088 return nil 3089} 3090 3091type awsRestjson1_deserializeOpPutMetadata struct { 3092} 3093 3094func (*awsRestjson1_deserializeOpPutMetadata) ID() string { 3095 return "OperationDeserializer" 3096} 3097 3098func (m *awsRestjson1_deserializeOpPutMetadata) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3099 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3100) { 3101 out, metadata, err = next.HandleDeserialize(ctx, in) 3102 if err != nil { 3103 return out, metadata, err 3104 } 3105 3106 response, ok := out.RawResponse.(*smithyhttp.Response) 3107 if !ok { 3108 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3109 } 3110 3111 if response.StatusCode < 200 || response.StatusCode >= 300 { 3112 return out, metadata, awsRestjson1_deserializeOpErrorPutMetadata(response, &metadata) 3113 } 3114 output := &PutMetadataOutput{} 3115 out.Result = output 3116 3117 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3118 return out, metadata, &smithy.DeserializationError{ 3119 Err: fmt.Errorf("failed to discard response body, %w", err), 3120 } 3121 } 3122 3123 return out, metadata, err 3124} 3125 3126func awsRestjson1_deserializeOpErrorPutMetadata(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3127 var errorBuffer bytes.Buffer 3128 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3129 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3130 } 3131 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3132 3133 errorCode := "UnknownError" 3134 errorMessage := errorCode 3135 3136 code := response.Header.Get("X-Amzn-ErrorType") 3137 if len(code) != 0 { 3138 errorCode = restjson.SanitizeErrorCode(code) 3139 } 3140 3141 var buff [1024]byte 3142 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3143 3144 body := io.TeeReader(errorBody, ringBuffer) 3145 decoder := json.NewDecoder(body) 3146 decoder.UseNumber() 3147 code, message, err := restjson.GetErrorInfo(decoder) 3148 if err != nil { 3149 var snapshot bytes.Buffer 3150 io.Copy(&snapshot, ringBuffer) 3151 err = &smithy.DeserializationError{ 3152 Err: fmt.Errorf("failed to decode response body, %w", err), 3153 Snapshot: snapshot.Bytes(), 3154 } 3155 return err 3156 } 3157 3158 errorBody.Seek(0, io.SeekStart) 3159 if len(code) != 0 { 3160 errorCode = restjson.SanitizeErrorCode(code) 3161 } 3162 if len(message) != 0 { 3163 errorMessage = message 3164 } 3165 3166 switch { 3167 case strings.EqualFold("AccessDeniedException", errorCode): 3168 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3169 3170 case strings.EqualFold("ChannelNotBroadcasting", errorCode): 3171 return awsRestjson1_deserializeErrorChannelNotBroadcasting(response, errorBody) 3172 3173 case strings.EqualFold("ResourceNotFoundException", errorCode): 3174 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3175 3176 case strings.EqualFold("ThrottlingException", errorCode): 3177 return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) 3178 3179 case strings.EqualFold("ValidationException", errorCode): 3180 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3181 3182 default: 3183 genericError := &smithy.GenericAPIError{ 3184 Code: errorCode, 3185 Message: errorMessage, 3186 } 3187 return genericError 3188 3189 } 3190} 3191 3192type awsRestjson1_deserializeOpStopStream struct { 3193} 3194 3195func (*awsRestjson1_deserializeOpStopStream) ID() string { 3196 return "OperationDeserializer" 3197} 3198 3199func (m *awsRestjson1_deserializeOpStopStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3200 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3201) { 3202 out, metadata, err = next.HandleDeserialize(ctx, in) 3203 if err != nil { 3204 return out, metadata, err 3205 } 3206 3207 response, ok := out.RawResponse.(*smithyhttp.Response) 3208 if !ok { 3209 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3210 } 3211 3212 if response.StatusCode < 200 || response.StatusCode >= 300 { 3213 return out, metadata, awsRestjson1_deserializeOpErrorStopStream(response, &metadata) 3214 } 3215 output := &StopStreamOutput{} 3216 out.Result = output 3217 3218 return out, metadata, err 3219} 3220 3221func awsRestjson1_deserializeOpErrorStopStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3222 var errorBuffer bytes.Buffer 3223 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3224 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3225 } 3226 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3227 3228 errorCode := "UnknownError" 3229 errorMessage := errorCode 3230 3231 code := response.Header.Get("X-Amzn-ErrorType") 3232 if len(code) != 0 { 3233 errorCode = restjson.SanitizeErrorCode(code) 3234 } 3235 3236 var buff [1024]byte 3237 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3238 3239 body := io.TeeReader(errorBody, ringBuffer) 3240 decoder := json.NewDecoder(body) 3241 decoder.UseNumber() 3242 code, message, err := restjson.GetErrorInfo(decoder) 3243 if err != nil { 3244 var snapshot bytes.Buffer 3245 io.Copy(&snapshot, ringBuffer) 3246 err = &smithy.DeserializationError{ 3247 Err: fmt.Errorf("failed to decode response body, %w", err), 3248 Snapshot: snapshot.Bytes(), 3249 } 3250 return err 3251 } 3252 3253 errorBody.Seek(0, io.SeekStart) 3254 if len(code) != 0 { 3255 errorCode = restjson.SanitizeErrorCode(code) 3256 } 3257 if len(message) != 0 { 3258 errorMessage = message 3259 } 3260 3261 switch { 3262 case strings.EqualFold("AccessDeniedException", errorCode): 3263 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3264 3265 case strings.EqualFold("ChannelNotBroadcasting", errorCode): 3266 return awsRestjson1_deserializeErrorChannelNotBroadcasting(response, errorBody) 3267 3268 case strings.EqualFold("ResourceNotFoundException", errorCode): 3269 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3270 3271 case strings.EqualFold("StreamUnavailable", errorCode): 3272 return awsRestjson1_deserializeErrorStreamUnavailable(response, errorBody) 3273 3274 case strings.EqualFold("ValidationException", errorCode): 3275 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3276 3277 default: 3278 genericError := &smithy.GenericAPIError{ 3279 Code: errorCode, 3280 Message: errorMessage, 3281 } 3282 return genericError 3283 3284 } 3285} 3286 3287type awsRestjson1_deserializeOpTagResource struct { 3288} 3289 3290func (*awsRestjson1_deserializeOpTagResource) ID() string { 3291 return "OperationDeserializer" 3292} 3293 3294func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3295 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3296) { 3297 out, metadata, err = next.HandleDeserialize(ctx, in) 3298 if err != nil { 3299 return out, metadata, err 3300 } 3301 3302 response, ok := out.RawResponse.(*smithyhttp.Response) 3303 if !ok { 3304 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3305 } 3306 3307 if response.StatusCode < 200 || response.StatusCode >= 300 { 3308 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 3309 } 3310 output := &TagResourceOutput{} 3311 out.Result = output 3312 3313 return out, metadata, err 3314} 3315 3316func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3317 var errorBuffer bytes.Buffer 3318 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3319 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3320 } 3321 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3322 3323 errorCode := "UnknownError" 3324 errorMessage := errorCode 3325 3326 code := response.Header.Get("X-Amzn-ErrorType") 3327 if len(code) != 0 { 3328 errorCode = restjson.SanitizeErrorCode(code) 3329 } 3330 3331 var buff [1024]byte 3332 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3333 3334 body := io.TeeReader(errorBody, ringBuffer) 3335 decoder := json.NewDecoder(body) 3336 decoder.UseNumber() 3337 code, message, err := restjson.GetErrorInfo(decoder) 3338 if err != nil { 3339 var snapshot bytes.Buffer 3340 io.Copy(&snapshot, ringBuffer) 3341 err = &smithy.DeserializationError{ 3342 Err: fmt.Errorf("failed to decode response body, %w", err), 3343 Snapshot: snapshot.Bytes(), 3344 } 3345 return err 3346 } 3347 3348 errorBody.Seek(0, io.SeekStart) 3349 if len(code) != 0 { 3350 errorCode = restjson.SanitizeErrorCode(code) 3351 } 3352 if len(message) != 0 { 3353 errorMessage = message 3354 } 3355 3356 switch { 3357 case strings.EqualFold("InternalServerException", errorCode): 3358 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3359 3360 case strings.EqualFold("ResourceNotFoundException", errorCode): 3361 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3362 3363 case strings.EqualFold("ValidationException", errorCode): 3364 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3365 3366 default: 3367 genericError := &smithy.GenericAPIError{ 3368 Code: errorCode, 3369 Message: errorMessage, 3370 } 3371 return genericError 3372 3373 } 3374} 3375 3376type awsRestjson1_deserializeOpUntagResource struct { 3377} 3378 3379func (*awsRestjson1_deserializeOpUntagResource) ID() string { 3380 return "OperationDeserializer" 3381} 3382 3383func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3384 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3385) { 3386 out, metadata, err = next.HandleDeserialize(ctx, in) 3387 if err != nil { 3388 return out, metadata, err 3389 } 3390 3391 response, ok := out.RawResponse.(*smithyhttp.Response) 3392 if !ok { 3393 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3394 } 3395 3396 if response.StatusCode < 200 || response.StatusCode >= 300 { 3397 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 3398 } 3399 output := &UntagResourceOutput{} 3400 out.Result = output 3401 3402 return out, metadata, err 3403} 3404 3405func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3406 var errorBuffer bytes.Buffer 3407 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3408 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3409 } 3410 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3411 3412 errorCode := "UnknownError" 3413 errorMessage := errorCode 3414 3415 code := response.Header.Get("X-Amzn-ErrorType") 3416 if len(code) != 0 { 3417 errorCode = restjson.SanitizeErrorCode(code) 3418 } 3419 3420 var buff [1024]byte 3421 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3422 3423 body := io.TeeReader(errorBody, ringBuffer) 3424 decoder := json.NewDecoder(body) 3425 decoder.UseNumber() 3426 code, message, err := restjson.GetErrorInfo(decoder) 3427 if err != nil { 3428 var snapshot bytes.Buffer 3429 io.Copy(&snapshot, ringBuffer) 3430 err = &smithy.DeserializationError{ 3431 Err: fmt.Errorf("failed to decode response body, %w", err), 3432 Snapshot: snapshot.Bytes(), 3433 } 3434 return err 3435 } 3436 3437 errorBody.Seek(0, io.SeekStart) 3438 if len(code) != 0 { 3439 errorCode = restjson.SanitizeErrorCode(code) 3440 } 3441 if len(message) != 0 { 3442 errorMessage = message 3443 } 3444 3445 switch { 3446 case strings.EqualFold("InternalServerException", errorCode): 3447 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 3448 3449 case strings.EqualFold("ResourceNotFoundException", errorCode): 3450 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3451 3452 case strings.EqualFold("ValidationException", errorCode): 3453 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3454 3455 default: 3456 genericError := &smithy.GenericAPIError{ 3457 Code: errorCode, 3458 Message: errorMessage, 3459 } 3460 return genericError 3461 3462 } 3463} 3464 3465type awsRestjson1_deserializeOpUpdateChannel struct { 3466} 3467 3468func (*awsRestjson1_deserializeOpUpdateChannel) ID() string { 3469 return "OperationDeserializer" 3470} 3471 3472func (m *awsRestjson1_deserializeOpUpdateChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3473 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3474) { 3475 out, metadata, err = next.HandleDeserialize(ctx, in) 3476 if err != nil { 3477 return out, metadata, err 3478 } 3479 3480 response, ok := out.RawResponse.(*smithyhttp.Response) 3481 if !ok { 3482 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3483 } 3484 3485 if response.StatusCode < 200 || response.StatusCode >= 300 { 3486 return out, metadata, awsRestjson1_deserializeOpErrorUpdateChannel(response, &metadata) 3487 } 3488 output := &UpdateChannelOutput{} 3489 out.Result = output 3490 3491 var buff [1024]byte 3492 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3493 3494 body := io.TeeReader(response.Body, ringBuffer) 3495 3496 decoder := json.NewDecoder(body) 3497 decoder.UseNumber() 3498 var shape interface{} 3499 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3500 var snapshot bytes.Buffer 3501 io.Copy(&snapshot, ringBuffer) 3502 err = &smithy.DeserializationError{ 3503 Err: fmt.Errorf("failed to decode response body, %w", err), 3504 Snapshot: snapshot.Bytes(), 3505 } 3506 return out, metadata, err 3507 } 3508 3509 err = awsRestjson1_deserializeOpDocumentUpdateChannelOutput(&output, shape) 3510 if err != nil { 3511 var snapshot bytes.Buffer 3512 io.Copy(&snapshot, ringBuffer) 3513 return out, metadata, &smithy.DeserializationError{ 3514 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3515 Snapshot: snapshot.Bytes(), 3516 } 3517 } 3518 3519 return out, metadata, err 3520} 3521 3522func awsRestjson1_deserializeOpErrorUpdateChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3523 var errorBuffer bytes.Buffer 3524 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3525 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3526 } 3527 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3528 3529 errorCode := "UnknownError" 3530 errorMessage := errorCode 3531 3532 code := response.Header.Get("X-Amzn-ErrorType") 3533 if len(code) != 0 { 3534 errorCode = restjson.SanitizeErrorCode(code) 3535 } 3536 3537 var buff [1024]byte 3538 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3539 3540 body := io.TeeReader(errorBody, ringBuffer) 3541 decoder := json.NewDecoder(body) 3542 decoder.UseNumber() 3543 code, message, err := restjson.GetErrorInfo(decoder) 3544 if err != nil { 3545 var snapshot bytes.Buffer 3546 io.Copy(&snapshot, ringBuffer) 3547 err = &smithy.DeserializationError{ 3548 Err: fmt.Errorf("failed to decode response body, %w", err), 3549 Snapshot: snapshot.Bytes(), 3550 } 3551 return err 3552 } 3553 3554 errorBody.Seek(0, io.SeekStart) 3555 if len(code) != 0 { 3556 errorCode = restjson.SanitizeErrorCode(code) 3557 } 3558 if len(message) != 0 { 3559 errorMessage = message 3560 } 3561 3562 switch { 3563 case strings.EqualFold("AccessDeniedException", errorCode): 3564 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3565 3566 case strings.EqualFold("ConflictException", errorCode): 3567 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3568 3569 case strings.EqualFold("PendingVerification", errorCode): 3570 return awsRestjson1_deserializeErrorPendingVerification(response, errorBody) 3571 3572 case strings.EqualFold("ResourceNotFoundException", errorCode): 3573 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3574 3575 case strings.EqualFold("ValidationException", errorCode): 3576 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3577 3578 default: 3579 genericError := &smithy.GenericAPIError{ 3580 Code: errorCode, 3581 Message: errorMessage, 3582 } 3583 return genericError 3584 3585 } 3586} 3587 3588func awsRestjson1_deserializeOpDocumentUpdateChannelOutput(v **UpdateChannelOutput, value interface{}) error { 3589 if v == nil { 3590 return fmt.Errorf("unexpected nil of type %T", v) 3591 } 3592 if value == nil { 3593 return nil 3594 } 3595 3596 shape, ok := value.(map[string]interface{}) 3597 if !ok { 3598 return fmt.Errorf("unexpected JSON type %v", value) 3599 } 3600 3601 var sv *UpdateChannelOutput 3602 if *v == nil { 3603 sv = &UpdateChannelOutput{} 3604 } else { 3605 sv = *v 3606 } 3607 3608 for key, value := range shape { 3609 switch key { 3610 case "channel": 3611 if err := awsRestjson1_deserializeDocumentChannel(&sv.Channel, value); err != nil { 3612 return err 3613 } 3614 3615 default: 3616 _, _ = key, value 3617 3618 } 3619 } 3620 *v = sv 3621 return nil 3622} 3623 3624func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3625 output := &types.AccessDeniedException{} 3626 var buff [1024]byte 3627 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3628 3629 body := io.TeeReader(errorBody, ringBuffer) 3630 decoder := json.NewDecoder(body) 3631 decoder.UseNumber() 3632 var shape interface{} 3633 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3634 var snapshot bytes.Buffer 3635 io.Copy(&snapshot, ringBuffer) 3636 err = &smithy.DeserializationError{ 3637 Err: fmt.Errorf("failed to decode response body, %w", err), 3638 Snapshot: snapshot.Bytes(), 3639 } 3640 return err 3641 } 3642 3643 err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape) 3644 3645 if err != nil { 3646 var snapshot bytes.Buffer 3647 io.Copy(&snapshot, ringBuffer) 3648 err = &smithy.DeserializationError{ 3649 Err: fmt.Errorf("failed to decode response body, %w", err), 3650 Snapshot: snapshot.Bytes(), 3651 } 3652 return err 3653 } 3654 3655 errorBody.Seek(0, io.SeekStart) 3656 3657 return output 3658} 3659 3660func awsRestjson1_deserializeErrorChannelNotBroadcasting(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3661 output := &types.ChannelNotBroadcasting{} 3662 var buff [1024]byte 3663 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3664 3665 body := io.TeeReader(errorBody, ringBuffer) 3666 decoder := json.NewDecoder(body) 3667 decoder.UseNumber() 3668 var shape interface{} 3669 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3670 var snapshot bytes.Buffer 3671 io.Copy(&snapshot, ringBuffer) 3672 err = &smithy.DeserializationError{ 3673 Err: fmt.Errorf("failed to decode response body, %w", err), 3674 Snapshot: snapshot.Bytes(), 3675 } 3676 return err 3677 } 3678 3679 err := awsRestjson1_deserializeDocumentChannelNotBroadcasting(&output, shape) 3680 3681 if err != nil { 3682 var snapshot bytes.Buffer 3683 io.Copy(&snapshot, ringBuffer) 3684 err = &smithy.DeserializationError{ 3685 Err: fmt.Errorf("failed to decode response body, %w", err), 3686 Snapshot: snapshot.Bytes(), 3687 } 3688 return err 3689 } 3690 3691 errorBody.Seek(0, io.SeekStart) 3692 3693 return output 3694} 3695 3696func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3697 output := &types.ConflictException{} 3698 var buff [1024]byte 3699 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3700 3701 body := io.TeeReader(errorBody, ringBuffer) 3702 decoder := json.NewDecoder(body) 3703 decoder.UseNumber() 3704 var shape interface{} 3705 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3706 var snapshot bytes.Buffer 3707 io.Copy(&snapshot, ringBuffer) 3708 err = &smithy.DeserializationError{ 3709 Err: fmt.Errorf("failed to decode response body, %w", err), 3710 Snapshot: snapshot.Bytes(), 3711 } 3712 return err 3713 } 3714 3715 err := awsRestjson1_deserializeDocumentConflictException(&output, shape) 3716 3717 if err != nil { 3718 var snapshot bytes.Buffer 3719 io.Copy(&snapshot, ringBuffer) 3720 err = &smithy.DeserializationError{ 3721 Err: fmt.Errorf("failed to decode response body, %w", err), 3722 Snapshot: snapshot.Bytes(), 3723 } 3724 return err 3725 } 3726 3727 errorBody.Seek(0, io.SeekStart) 3728 3729 return output 3730} 3731 3732func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3733 output := &types.InternalServerException{} 3734 var buff [1024]byte 3735 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3736 3737 body := io.TeeReader(errorBody, ringBuffer) 3738 decoder := json.NewDecoder(body) 3739 decoder.UseNumber() 3740 var shape interface{} 3741 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3742 var snapshot bytes.Buffer 3743 io.Copy(&snapshot, ringBuffer) 3744 err = &smithy.DeserializationError{ 3745 Err: fmt.Errorf("failed to decode response body, %w", err), 3746 Snapshot: snapshot.Bytes(), 3747 } 3748 return err 3749 } 3750 3751 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape) 3752 3753 if err != nil { 3754 var snapshot bytes.Buffer 3755 io.Copy(&snapshot, ringBuffer) 3756 err = &smithy.DeserializationError{ 3757 Err: fmt.Errorf("failed to decode response body, %w", err), 3758 Snapshot: snapshot.Bytes(), 3759 } 3760 return err 3761 } 3762 3763 errorBody.Seek(0, io.SeekStart) 3764 3765 return output 3766} 3767 3768func awsRestjson1_deserializeErrorPendingVerification(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3769 output := &types.PendingVerification{} 3770 var buff [1024]byte 3771 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3772 3773 body := io.TeeReader(errorBody, ringBuffer) 3774 decoder := json.NewDecoder(body) 3775 decoder.UseNumber() 3776 var shape interface{} 3777 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3778 var snapshot bytes.Buffer 3779 io.Copy(&snapshot, ringBuffer) 3780 err = &smithy.DeserializationError{ 3781 Err: fmt.Errorf("failed to decode response body, %w", err), 3782 Snapshot: snapshot.Bytes(), 3783 } 3784 return err 3785 } 3786 3787 err := awsRestjson1_deserializeDocumentPendingVerification(&output, shape) 3788 3789 if err != nil { 3790 var snapshot bytes.Buffer 3791 io.Copy(&snapshot, ringBuffer) 3792 err = &smithy.DeserializationError{ 3793 Err: fmt.Errorf("failed to decode response body, %w", err), 3794 Snapshot: snapshot.Bytes(), 3795 } 3796 return err 3797 } 3798 3799 errorBody.Seek(0, io.SeekStart) 3800 3801 return output 3802} 3803 3804func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3805 output := &types.ResourceNotFoundException{} 3806 var buff [1024]byte 3807 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3808 3809 body := io.TeeReader(errorBody, ringBuffer) 3810 decoder := json.NewDecoder(body) 3811 decoder.UseNumber() 3812 var shape interface{} 3813 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3814 var snapshot bytes.Buffer 3815 io.Copy(&snapshot, ringBuffer) 3816 err = &smithy.DeserializationError{ 3817 Err: fmt.Errorf("failed to decode response body, %w", err), 3818 Snapshot: snapshot.Bytes(), 3819 } 3820 return err 3821 } 3822 3823 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 3824 3825 if err != nil { 3826 var snapshot bytes.Buffer 3827 io.Copy(&snapshot, ringBuffer) 3828 err = &smithy.DeserializationError{ 3829 Err: fmt.Errorf("failed to decode response body, %w", err), 3830 Snapshot: snapshot.Bytes(), 3831 } 3832 return err 3833 } 3834 3835 errorBody.Seek(0, io.SeekStart) 3836 3837 return output 3838} 3839 3840func awsRestjson1_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3841 output := &types.ServiceQuotaExceededException{} 3842 var buff [1024]byte 3843 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3844 3845 body := io.TeeReader(errorBody, ringBuffer) 3846 decoder := json.NewDecoder(body) 3847 decoder.UseNumber() 3848 var shape interface{} 3849 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3850 var snapshot bytes.Buffer 3851 io.Copy(&snapshot, ringBuffer) 3852 err = &smithy.DeserializationError{ 3853 Err: fmt.Errorf("failed to decode response body, %w", err), 3854 Snapshot: snapshot.Bytes(), 3855 } 3856 return err 3857 } 3858 3859 err := awsRestjson1_deserializeDocumentServiceQuotaExceededException(&output, shape) 3860 3861 if err != nil { 3862 var snapshot bytes.Buffer 3863 io.Copy(&snapshot, ringBuffer) 3864 err = &smithy.DeserializationError{ 3865 Err: fmt.Errorf("failed to decode response body, %w", err), 3866 Snapshot: snapshot.Bytes(), 3867 } 3868 return err 3869 } 3870 3871 errorBody.Seek(0, io.SeekStart) 3872 3873 return output 3874} 3875 3876func awsRestjson1_deserializeErrorStreamUnavailable(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3877 output := &types.StreamUnavailable{} 3878 var buff [1024]byte 3879 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3880 3881 body := io.TeeReader(errorBody, ringBuffer) 3882 decoder := json.NewDecoder(body) 3883 decoder.UseNumber() 3884 var shape interface{} 3885 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3886 var snapshot bytes.Buffer 3887 io.Copy(&snapshot, ringBuffer) 3888 err = &smithy.DeserializationError{ 3889 Err: fmt.Errorf("failed to decode response body, %w", err), 3890 Snapshot: snapshot.Bytes(), 3891 } 3892 return err 3893 } 3894 3895 err := awsRestjson1_deserializeDocumentStreamUnavailable(&output, shape) 3896 3897 if err != nil { 3898 var snapshot bytes.Buffer 3899 io.Copy(&snapshot, ringBuffer) 3900 err = &smithy.DeserializationError{ 3901 Err: fmt.Errorf("failed to decode response body, %w", err), 3902 Snapshot: snapshot.Bytes(), 3903 } 3904 return err 3905 } 3906 3907 errorBody.Seek(0, io.SeekStart) 3908 3909 return output 3910} 3911 3912func awsRestjson1_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3913 output := &types.ThrottlingException{} 3914 var buff [1024]byte 3915 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3916 3917 body := io.TeeReader(errorBody, ringBuffer) 3918 decoder := json.NewDecoder(body) 3919 decoder.UseNumber() 3920 var shape interface{} 3921 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3922 var snapshot bytes.Buffer 3923 io.Copy(&snapshot, ringBuffer) 3924 err = &smithy.DeserializationError{ 3925 Err: fmt.Errorf("failed to decode response body, %w", err), 3926 Snapshot: snapshot.Bytes(), 3927 } 3928 return err 3929 } 3930 3931 err := awsRestjson1_deserializeDocumentThrottlingException(&output, shape) 3932 3933 if err != nil { 3934 var snapshot bytes.Buffer 3935 io.Copy(&snapshot, ringBuffer) 3936 err = &smithy.DeserializationError{ 3937 Err: fmt.Errorf("failed to decode response body, %w", err), 3938 Snapshot: snapshot.Bytes(), 3939 } 3940 return err 3941 } 3942 3943 errorBody.Seek(0, io.SeekStart) 3944 3945 return output 3946} 3947 3948func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3949 output := &types.ValidationException{} 3950 var buff [1024]byte 3951 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3952 3953 body := io.TeeReader(errorBody, ringBuffer) 3954 decoder := json.NewDecoder(body) 3955 decoder.UseNumber() 3956 var shape interface{} 3957 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3958 var snapshot bytes.Buffer 3959 io.Copy(&snapshot, ringBuffer) 3960 err = &smithy.DeserializationError{ 3961 Err: fmt.Errorf("failed to decode response body, %w", err), 3962 Snapshot: snapshot.Bytes(), 3963 } 3964 return err 3965 } 3966 3967 err := awsRestjson1_deserializeDocumentValidationException(&output, shape) 3968 3969 if err != nil { 3970 var snapshot bytes.Buffer 3971 io.Copy(&snapshot, ringBuffer) 3972 err = &smithy.DeserializationError{ 3973 Err: fmt.Errorf("failed to decode response body, %w", err), 3974 Snapshot: snapshot.Bytes(), 3975 } 3976 return err 3977 } 3978 3979 errorBody.Seek(0, io.SeekStart) 3980 3981 return output 3982} 3983 3984func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 3985 if v == nil { 3986 return fmt.Errorf("unexpected nil of type %T", v) 3987 } 3988 if value == nil { 3989 return nil 3990 } 3991 3992 shape, ok := value.(map[string]interface{}) 3993 if !ok { 3994 return fmt.Errorf("unexpected JSON type %v", value) 3995 } 3996 3997 var sv *types.AccessDeniedException 3998 if *v == nil { 3999 sv = &types.AccessDeniedException{} 4000 } else { 4001 sv = *v 4002 } 4003 4004 for key, value := range shape { 4005 switch key { 4006 case "exceptionMessage": 4007 if value != nil { 4008 jtv, ok := value.(string) 4009 if !ok { 4010 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4011 } 4012 sv.ExceptionMessage = ptr.String(jtv) 4013 } 4014 4015 default: 4016 _, _ = key, value 4017 4018 } 4019 } 4020 *v = sv 4021 return nil 4022} 4023 4024func awsRestjson1_deserializeDocumentBatchError(v **types.BatchError, value interface{}) error { 4025 if v == nil { 4026 return fmt.Errorf("unexpected nil of type %T", v) 4027 } 4028 if value == nil { 4029 return nil 4030 } 4031 4032 shape, ok := value.(map[string]interface{}) 4033 if !ok { 4034 return fmt.Errorf("unexpected JSON type %v", value) 4035 } 4036 4037 var sv *types.BatchError 4038 if *v == nil { 4039 sv = &types.BatchError{} 4040 } else { 4041 sv = *v 4042 } 4043 4044 for key, value := range shape { 4045 switch key { 4046 case "arn": 4047 if value != nil { 4048 jtv, ok := value.(string) 4049 if !ok { 4050 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 4051 } 4052 sv.Arn = ptr.String(jtv) 4053 } 4054 4055 case "code": 4056 if value != nil { 4057 jtv, ok := value.(string) 4058 if !ok { 4059 return fmt.Errorf("expected errorCode to be of type string, got %T instead", value) 4060 } 4061 sv.Code = ptr.String(jtv) 4062 } 4063 4064 case "message": 4065 if value != nil { 4066 jtv, ok := value.(string) 4067 if !ok { 4068 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4069 } 4070 sv.Message = ptr.String(jtv) 4071 } 4072 4073 default: 4074 _, _ = key, value 4075 4076 } 4077 } 4078 *v = sv 4079 return nil 4080} 4081 4082func awsRestjson1_deserializeDocumentBatchErrors(v *[]types.BatchError, value interface{}) error { 4083 if v == nil { 4084 return fmt.Errorf("unexpected nil of type %T", v) 4085 } 4086 if value == nil { 4087 return nil 4088 } 4089 4090 shape, ok := value.([]interface{}) 4091 if !ok { 4092 return fmt.Errorf("unexpected JSON type %v", value) 4093 } 4094 4095 var cv []types.BatchError 4096 if *v == nil { 4097 cv = []types.BatchError{} 4098 } else { 4099 cv = *v 4100 } 4101 4102 for _, value := range shape { 4103 var col types.BatchError 4104 destAddr := &col 4105 if err := awsRestjson1_deserializeDocumentBatchError(&destAddr, value); err != nil { 4106 return err 4107 } 4108 col = *destAddr 4109 cv = append(cv, col) 4110 4111 } 4112 *v = cv 4113 return nil 4114} 4115 4116func awsRestjson1_deserializeDocumentChannel(v **types.Channel, value interface{}) error { 4117 if v == nil { 4118 return fmt.Errorf("unexpected nil of type %T", v) 4119 } 4120 if value == nil { 4121 return nil 4122 } 4123 4124 shape, ok := value.(map[string]interface{}) 4125 if !ok { 4126 return fmt.Errorf("unexpected JSON type %v", value) 4127 } 4128 4129 var sv *types.Channel 4130 if *v == nil { 4131 sv = &types.Channel{} 4132 } else { 4133 sv = *v 4134 } 4135 4136 for key, value := range shape { 4137 switch key { 4138 case "arn": 4139 if value != nil { 4140 jtv, ok := value.(string) 4141 if !ok { 4142 return fmt.Errorf("expected ChannelArn to be of type string, got %T instead", value) 4143 } 4144 sv.Arn = ptr.String(jtv) 4145 } 4146 4147 case "authorized": 4148 if value != nil { 4149 jtv, ok := value.(bool) 4150 if !ok { 4151 return fmt.Errorf("expected IsAuthorized to be of type *bool, got %T instead", value) 4152 } 4153 sv.Authorized = jtv 4154 } 4155 4156 case "ingestEndpoint": 4157 if value != nil { 4158 jtv, ok := value.(string) 4159 if !ok { 4160 return fmt.Errorf("expected IngestEndpoint to be of type string, got %T instead", value) 4161 } 4162 sv.IngestEndpoint = ptr.String(jtv) 4163 } 4164 4165 case "latencyMode": 4166 if value != nil { 4167 jtv, ok := value.(string) 4168 if !ok { 4169 return fmt.Errorf("expected ChannelLatencyMode to be of type string, got %T instead", value) 4170 } 4171 sv.LatencyMode = types.ChannelLatencyMode(jtv) 4172 } 4173 4174 case "name": 4175 if value != nil { 4176 jtv, ok := value.(string) 4177 if !ok { 4178 return fmt.Errorf("expected ChannelName to be of type string, got %T instead", value) 4179 } 4180 sv.Name = ptr.String(jtv) 4181 } 4182 4183 case "playbackUrl": 4184 if value != nil { 4185 jtv, ok := value.(string) 4186 if !ok { 4187 return fmt.Errorf("expected PlaybackURL to be of type string, got %T instead", value) 4188 } 4189 sv.PlaybackUrl = ptr.String(jtv) 4190 } 4191 4192 case "recordingConfigurationArn": 4193 if value != nil { 4194 jtv, ok := value.(string) 4195 if !ok { 4196 return fmt.Errorf("expected ChannelRecordingConfigurationArn to be of type string, got %T instead", value) 4197 } 4198 sv.RecordingConfigurationArn = ptr.String(jtv) 4199 } 4200 4201 case "tags": 4202 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 4203 return err 4204 } 4205 4206 case "type": 4207 if value != nil { 4208 jtv, ok := value.(string) 4209 if !ok { 4210 return fmt.Errorf("expected ChannelType to be of type string, got %T instead", value) 4211 } 4212 sv.Type = types.ChannelType(jtv) 4213 } 4214 4215 default: 4216 _, _ = key, value 4217 4218 } 4219 } 4220 *v = sv 4221 return nil 4222} 4223 4224func awsRestjson1_deserializeDocumentChannelList(v *[]types.ChannelSummary, value interface{}) error { 4225 if v == nil { 4226 return fmt.Errorf("unexpected nil of type %T", v) 4227 } 4228 if value == nil { 4229 return nil 4230 } 4231 4232 shape, ok := value.([]interface{}) 4233 if !ok { 4234 return fmt.Errorf("unexpected JSON type %v", value) 4235 } 4236 4237 var cv []types.ChannelSummary 4238 if *v == nil { 4239 cv = []types.ChannelSummary{} 4240 } else { 4241 cv = *v 4242 } 4243 4244 for _, value := range shape { 4245 var col types.ChannelSummary 4246 destAddr := &col 4247 if err := awsRestjson1_deserializeDocumentChannelSummary(&destAddr, value); err != nil { 4248 return err 4249 } 4250 col = *destAddr 4251 cv = append(cv, col) 4252 4253 } 4254 *v = cv 4255 return nil 4256} 4257 4258func awsRestjson1_deserializeDocumentChannelNotBroadcasting(v **types.ChannelNotBroadcasting, 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 *types.ChannelNotBroadcasting 4272 if *v == nil { 4273 sv = &types.ChannelNotBroadcasting{} 4274 } else { 4275 sv = *v 4276 } 4277 4278 for key, value := range shape { 4279 switch key { 4280 case "exceptionMessage": 4281 if value != nil { 4282 jtv, ok := value.(string) 4283 if !ok { 4284 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4285 } 4286 sv.ExceptionMessage = ptr.String(jtv) 4287 } 4288 4289 default: 4290 _, _ = key, value 4291 4292 } 4293 } 4294 *v = sv 4295 return nil 4296} 4297 4298func awsRestjson1_deserializeDocumentChannels(v *[]types.Channel, value interface{}) error { 4299 if v == nil { 4300 return fmt.Errorf("unexpected nil of type %T", v) 4301 } 4302 if value == nil { 4303 return nil 4304 } 4305 4306 shape, ok := value.([]interface{}) 4307 if !ok { 4308 return fmt.Errorf("unexpected JSON type %v", value) 4309 } 4310 4311 var cv []types.Channel 4312 if *v == nil { 4313 cv = []types.Channel{} 4314 } else { 4315 cv = *v 4316 } 4317 4318 for _, value := range shape { 4319 var col types.Channel 4320 destAddr := &col 4321 if err := awsRestjson1_deserializeDocumentChannel(&destAddr, value); err != nil { 4322 return err 4323 } 4324 col = *destAddr 4325 cv = append(cv, col) 4326 4327 } 4328 *v = cv 4329 return nil 4330} 4331 4332func awsRestjson1_deserializeDocumentChannelSummary(v **types.ChannelSummary, value interface{}) error { 4333 if v == nil { 4334 return fmt.Errorf("unexpected nil of type %T", v) 4335 } 4336 if value == nil { 4337 return nil 4338 } 4339 4340 shape, ok := value.(map[string]interface{}) 4341 if !ok { 4342 return fmt.Errorf("unexpected JSON type %v", value) 4343 } 4344 4345 var sv *types.ChannelSummary 4346 if *v == nil { 4347 sv = &types.ChannelSummary{} 4348 } else { 4349 sv = *v 4350 } 4351 4352 for key, value := range shape { 4353 switch key { 4354 case "arn": 4355 if value != nil { 4356 jtv, ok := value.(string) 4357 if !ok { 4358 return fmt.Errorf("expected ChannelArn to be of type string, got %T instead", value) 4359 } 4360 sv.Arn = ptr.String(jtv) 4361 } 4362 4363 case "authorized": 4364 if value != nil { 4365 jtv, ok := value.(bool) 4366 if !ok { 4367 return fmt.Errorf("expected IsAuthorized to be of type *bool, got %T instead", value) 4368 } 4369 sv.Authorized = jtv 4370 } 4371 4372 case "latencyMode": 4373 if value != nil { 4374 jtv, ok := value.(string) 4375 if !ok { 4376 return fmt.Errorf("expected ChannelLatencyMode to be of type string, got %T instead", value) 4377 } 4378 sv.LatencyMode = types.ChannelLatencyMode(jtv) 4379 } 4380 4381 case "name": 4382 if value != nil { 4383 jtv, ok := value.(string) 4384 if !ok { 4385 return fmt.Errorf("expected ChannelName to be of type string, got %T instead", value) 4386 } 4387 sv.Name = ptr.String(jtv) 4388 } 4389 4390 case "recordingConfigurationArn": 4391 if value != nil { 4392 jtv, ok := value.(string) 4393 if !ok { 4394 return fmt.Errorf("expected ChannelRecordingConfigurationArn to be of type string, got %T instead", value) 4395 } 4396 sv.RecordingConfigurationArn = ptr.String(jtv) 4397 } 4398 4399 case "tags": 4400 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 4401 return err 4402 } 4403 4404 default: 4405 _, _ = key, value 4406 4407 } 4408 } 4409 *v = sv 4410 return nil 4411} 4412 4413func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 4414 if v == nil { 4415 return fmt.Errorf("unexpected nil of type %T", v) 4416 } 4417 if value == nil { 4418 return nil 4419 } 4420 4421 shape, ok := value.(map[string]interface{}) 4422 if !ok { 4423 return fmt.Errorf("unexpected JSON type %v", value) 4424 } 4425 4426 var sv *types.ConflictException 4427 if *v == nil { 4428 sv = &types.ConflictException{} 4429 } else { 4430 sv = *v 4431 } 4432 4433 for key, value := range shape { 4434 switch key { 4435 case "exceptionMessage": 4436 if value != nil { 4437 jtv, ok := value.(string) 4438 if !ok { 4439 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4440 } 4441 sv.ExceptionMessage = ptr.String(jtv) 4442 } 4443 4444 default: 4445 _, _ = key, value 4446 4447 } 4448 } 4449 *v = sv 4450 return nil 4451} 4452 4453func awsRestjson1_deserializeDocumentDestinationConfiguration(v **types.DestinationConfiguration, value interface{}) error { 4454 if v == nil { 4455 return fmt.Errorf("unexpected nil of type %T", v) 4456 } 4457 if value == nil { 4458 return nil 4459 } 4460 4461 shape, ok := value.(map[string]interface{}) 4462 if !ok { 4463 return fmt.Errorf("unexpected JSON type %v", value) 4464 } 4465 4466 var sv *types.DestinationConfiguration 4467 if *v == nil { 4468 sv = &types.DestinationConfiguration{} 4469 } else { 4470 sv = *v 4471 } 4472 4473 for key, value := range shape { 4474 switch key { 4475 case "s3": 4476 if err := awsRestjson1_deserializeDocumentS3DestinationConfiguration(&sv.S3, value); err != nil { 4477 return err 4478 } 4479 4480 default: 4481 _, _ = key, value 4482 4483 } 4484 } 4485 *v = sv 4486 return nil 4487} 4488 4489func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { 4490 if v == nil { 4491 return fmt.Errorf("unexpected nil of type %T", v) 4492 } 4493 if value == nil { 4494 return nil 4495 } 4496 4497 shape, ok := value.(map[string]interface{}) 4498 if !ok { 4499 return fmt.Errorf("unexpected JSON type %v", value) 4500 } 4501 4502 var sv *types.InternalServerException 4503 if *v == nil { 4504 sv = &types.InternalServerException{} 4505 } else { 4506 sv = *v 4507 } 4508 4509 for key, value := range shape { 4510 switch key { 4511 case "exceptionMessage": 4512 if value != nil { 4513 jtv, ok := value.(string) 4514 if !ok { 4515 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4516 } 4517 sv.ExceptionMessage = ptr.String(jtv) 4518 } 4519 4520 default: 4521 _, _ = key, value 4522 4523 } 4524 } 4525 *v = sv 4526 return nil 4527} 4528 4529func awsRestjson1_deserializeDocumentPendingVerification(v **types.PendingVerification, value interface{}) error { 4530 if v == nil { 4531 return fmt.Errorf("unexpected nil of type %T", v) 4532 } 4533 if value == nil { 4534 return nil 4535 } 4536 4537 shape, ok := value.(map[string]interface{}) 4538 if !ok { 4539 return fmt.Errorf("unexpected JSON type %v", value) 4540 } 4541 4542 var sv *types.PendingVerification 4543 if *v == nil { 4544 sv = &types.PendingVerification{} 4545 } else { 4546 sv = *v 4547 } 4548 4549 for key, value := range shape { 4550 switch key { 4551 case "exceptionMessage": 4552 if value != nil { 4553 jtv, ok := value.(string) 4554 if !ok { 4555 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4556 } 4557 sv.ExceptionMessage = ptr.String(jtv) 4558 } 4559 4560 default: 4561 _, _ = key, value 4562 4563 } 4564 } 4565 *v = sv 4566 return nil 4567} 4568 4569func awsRestjson1_deserializeDocumentPlaybackKeyPair(v **types.PlaybackKeyPair, value interface{}) error { 4570 if v == nil { 4571 return fmt.Errorf("unexpected nil of type %T", v) 4572 } 4573 if value == nil { 4574 return nil 4575 } 4576 4577 shape, ok := value.(map[string]interface{}) 4578 if !ok { 4579 return fmt.Errorf("unexpected JSON type %v", value) 4580 } 4581 4582 var sv *types.PlaybackKeyPair 4583 if *v == nil { 4584 sv = &types.PlaybackKeyPair{} 4585 } else { 4586 sv = *v 4587 } 4588 4589 for key, value := range shape { 4590 switch key { 4591 case "arn": 4592 if value != nil { 4593 jtv, ok := value.(string) 4594 if !ok { 4595 return fmt.Errorf("expected PlaybackKeyPairArn to be of type string, got %T instead", value) 4596 } 4597 sv.Arn = ptr.String(jtv) 4598 } 4599 4600 case "fingerprint": 4601 if value != nil { 4602 jtv, ok := value.(string) 4603 if !ok { 4604 return fmt.Errorf("expected PlaybackKeyPairFingerprint to be of type string, got %T instead", value) 4605 } 4606 sv.Fingerprint = ptr.String(jtv) 4607 } 4608 4609 case "name": 4610 if value != nil { 4611 jtv, ok := value.(string) 4612 if !ok { 4613 return fmt.Errorf("expected PlaybackKeyPairName to be of type string, got %T instead", value) 4614 } 4615 sv.Name = ptr.String(jtv) 4616 } 4617 4618 case "tags": 4619 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 4620 return err 4621 } 4622 4623 default: 4624 _, _ = key, value 4625 4626 } 4627 } 4628 *v = sv 4629 return nil 4630} 4631 4632func awsRestjson1_deserializeDocumentPlaybackKeyPairList(v *[]types.PlaybackKeyPairSummary, value interface{}) error { 4633 if v == nil { 4634 return fmt.Errorf("unexpected nil of type %T", v) 4635 } 4636 if value == nil { 4637 return nil 4638 } 4639 4640 shape, ok := value.([]interface{}) 4641 if !ok { 4642 return fmt.Errorf("unexpected JSON type %v", value) 4643 } 4644 4645 var cv []types.PlaybackKeyPairSummary 4646 if *v == nil { 4647 cv = []types.PlaybackKeyPairSummary{} 4648 } else { 4649 cv = *v 4650 } 4651 4652 for _, value := range shape { 4653 var col types.PlaybackKeyPairSummary 4654 destAddr := &col 4655 if err := awsRestjson1_deserializeDocumentPlaybackKeyPairSummary(&destAddr, value); err != nil { 4656 return err 4657 } 4658 col = *destAddr 4659 cv = append(cv, col) 4660 4661 } 4662 *v = cv 4663 return nil 4664} 4665 4666func awsRestjson1_deserializeDocumentPlaybackKeyPairSummary(v **types.PlaybackKeyPairSummary, value interface{}) error { 4667 if v == nil { 4668 return fmt.Errorf("unexpected nil of type %T", v) 4669 } 4670 if value == nil { 4671 return nil 4672 } 4673 4674 shape, ok := value.(map[string]interface{}) 4675 if !ok { 4676 return fmt.Errorf("unexpected JSON type %v", value) 4677 } 4678 4679 var sv *types.PlaybackKeyPairSummary 4680 if *v == nil { 4681 sv = &types.PlaybackKeyPairSummary{} 4682 } else { 4683 sv = *v 4684 } 4685 4686 for key, value := range shape { 4687 switch key { 4688 case "arn": 4689 if value != nil { 4690 jtv, ok := value.(string) 4691 if !ok { 4692 return fmt.Errorf("expected PlaybackKeyPairArn to be of type string, got %T instead", value) 4693 } 4694 sv.Arn = ptr.String(jtv) 4695 } 4696 4697 case "name": 4698 if value != nil { 4699 jtv, ok := value.(string) 4700 if !ok { 4701 return fmt.Errorf("expected PlaybackKeyPairName to be of type string, got %T instead", value) 4702 } 4703 sv.Name = ptr.String(jtv) 4704 } 4705 4706 case "tags": 4707 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 4708 return err 4709 } 4710 4711 default: 4712 _, _ = key, value 4713 4714 } 4715 } 4716 *v = sv 4717 return nil 4718} 4719 4720func awsRestjson1_deserializeDocumentRecordingConfiguration(v **types.RecordingConfiguration, value interface{}) error { 4721 if v == nil { 4722 return fmt.Errorf("unexpected nil of type %T", v) 4723 } 4724 if value == nil { 4725 return nil 4726 } 4727 4728 shape, ok := value.(map[string]interface{}) 4729 if !ok { 4730 return fmt.Errorf("unexpected JSON type %v", value) 4731 } 4732 4733 var sv *types.RecordingConfiguration 4734 if *v == nil { 4735 sv = &types.RecordingConfiguration{} 4736 } else { 4737 sv = *v 4738 } 4739 4740 for key, value := range shape { 4741 switch key { 4742 case "arn": 4743 if value != nil { 4744 jtv, ok := value.(string) 4745 if !ok { 4746 return fmt.Errorf("expected RecordingConfigurationArn to be of type string, got %T instead", value) 4747 } 4748 sv.Arn = ptr.String(jtv) 4749 } 4750 4751 case "destinationConfiguration": 4752 if err := awsRestjson1_deserializeDocumentDestinationConfiguration(&sv.DestinationConfiguration, value); err != nil { 4753 return err 4754 } 4755 4756 case "name": 4757 if value != nil { 4758 jtv, ok := value.(string) 4759 if !ok { 4760 return fmt.Errorf("expected RecordingConfigurationName to be of type string, got %T instead", value) 4761 } 4762 sv.Name = ptr.String(jtv) 4763 } 4764 4765 case "state": 4766 if value != nil { 4767 jtv, ok := value.(string) 4768 if !ok { 4769 return fmt.Errorf("expected RecordingConfigurationState to be of type string, got %T instead", value) 4770 } 4771 sv.State = types.RecordingConfigurationState(jtv) 4772 } 4773 4774 case "tags": 4775 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 4776 return err 4777 } 4778 4779 default: 4780 _, _ = key, value 4781 4782 } 4783 } 4784 *v = sv 4785 return nil 4786} 4787 4788func awsRestjson1_deserializeDocumentRecordingConfigurationList(v *[]types.RecordingConfigurationSummary, value interface{}) error { 4789 if v == nil { 4790 return fmt.Errorf("unexpected nil of type %T", v) 4791 } 4792 if value == nil { 4793 return nil 4794 } 4795 4796 shape, ok := value.([]interface{}) 4797 if !ok { 4798 return fmt.Errorf("unexpected JSON type %v", value) 4799 } 4800 4801 var cv []types.RecordingConfigurationSummary 4802 if *v == nil { 4803 cv = []types.RecordingConfigurationSummary{} 4804 } else { 4805 cv = *v 4806 } 4807 4808 for _, value := range shape { 4809 var col types.RecordingConfigurationSummary 4810 destAddr := &col 4811 if err := awsRestjson1_deserializeDocumentRecordingConfigurationSummary(&destAddr, value); err != nil { 4812 return err 4813 } 4814 col = *destAddr 4815 cv = append(cv, col) 4816 4817 } 4818 *v = cv 4819 return nil 4820} 4821 4822func awsRestjson1_deserializeDocumentRecordingConfigurationSummary(v **types.RecordingConfigurationSummary, value interface{}) error { 4823 if v == nil { 4824 return fmt.Errorf("unexpected nil of type %T", v) 4825 } 4826 if value == nil { 4827 return nil 4828 } 4829 4830 shape, ok := value.(map[string]interface{}) 4831 if !ok { 4832 return fmt.Errorf("unexpected JSON type %v", value) 4833 } 4834 4835 var sv *types.RecordingConfigurationSummary 4836 if *v == nil { 4837 sv = &types.RecordingConfigurationSummary{} 4838 } else { 4839 sv = *v 4840 } 4841 4842 for key, value := range shape { 4843 switch key { 4844 case "arn": 4845 if value != nil { 4846 jtv, ok := value.(string) 4847 if !ok { 4848 return fmt.Errorf("expected RecordingConfigurationArn to be of type string, got %T instead", value) 4849 } 4850 sv.Arn = ptr.String(jtv) 4851 } 4852 4853 case "destinationConfiguration": 4854 if err := awsRestjson1_deserializeDocumentDestinationConfiguration(&sv.DestinationConfiguration, value); err != nil { 4855 return err 4856 } 4857 4858 case "name": 4859 if value != nil { 4860 jtv, ok := value.(string) 4861 if !ok { 4862 return fmt.Errorf("expected RecordingConfigurationName to be of type string, got %T instead", value) 4863 } 4864 sv.Name = ptr.String(jtv) 4865 } 4866 4867 case "state": 4868 if value != nil { 4869 jtv, ok := value.(string) 4870 if !ok { 4871 return fmt.Errorf("expected RecordingConfigurationState to be of type string, got %T instead", value) 4872 } 4873 sv.State = types.RecordingConfigurationState(jtv) 4874 } 4875 4876 case "tags": 4877 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 4878 return err 4879 } 4880 4881 default: 4882 _, _ = key, value 4883 4884 } 4885 } 4886 *v = sv 4887 return nil 4888} 4889 4890func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 4891 if v == nil { 4892 return fmt.Errorf("unexpected nil of type %T", v) 4893 } 4894 if value == nil { 4895 return nil 4896 } 4897 4898 shape, ok := value.(map[string]interface{}) 4899 if !ok { 4900 return fmt.Errorf("unexpected JSON type %v", value) 4901 } 4902 4903 var sv *types.ResourceNotFoundException 4904 if *v == nil { 4905 sv = &types.ResourceNotFoundException{} 4906 } else { 4907 sv = *v 4908 } 4909 4910 for key, value := range shape { 4911 switch key { 4912 case "exceptionMessage": 4913 if value != nil { 4914 jtv, ok := value.(string) 4915 if !ok { 4916 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4917 } 4918 sv.ExceptionMessage = ptr.String(jtv) 4919 } 4920 4921 default: 4922 _, _ = key, value 4923 4924 } 4925 } 4926 *v = sv 4927 return nil 4928} 4929 4930func awsRestjson1_deserializeDocumentS3DestinationConfiguration(v **types.S3DestinationConfiguration, value interface{}) error { 4931 if v == nil { 4932 return fmt.Errorf("unexpected nil of type %T", v) 4933 } 4934 if value == nil { 4935 return nil 4936 } 4937 4938 shape, ok := value.(map[string]interface{}) 4939 if !ok { 4940 return fmt.Errorf("unexpected JSON type %v", value) 4941 } 4942 4943 var sv *types.S3DestinationConfiguration 4944 if *v == nil { 4945 sv = &types.S3DestinationConfiguration{} 4946 } else { 4947 sv = *v 4948 } 4949 4950 for key, value := range shape { 4951 switch key { 4952 case "bucketName": 4953 if value != nil { 4954 jtv, ok := value.(string) 4955 if !ok { 4956 return fmt.Errorf("expected S3DestinationBucketName to be of type string, got %T instead", value) 4957 } 4958 sv.BucketName = ptr.String(jtv) 4959 } 4960 4961 default: 4962 _, _ = key, value 4963 4964 } 4965 } 4966 *v = sv 4967 return nil 4968} 4969 4970func awsRestjson1_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error { 4971 if v == nil { 4972 return fmt.Errorf("unexpected nil of type %T", v) 4973 } 4974 if value == nil { 4975 return nil 4976 } 4977 4978 shape, ok := value.(map[string]interface{}) 4979 if !ok { 4980 return fmt.Errorf("unexpected JSON type %v", value) 4981 } 4982 4983 var sv *types.ServiceQuotaExceededException 4984 if *v == nil { 4985 sv = &types.ServiceQuotaExceededException{} 4986 } else { 4987 sv = *v 4988 } 4989 4990 for key, value := range shape { 4991 switch key { 4992 case "exceptionMessage": 4993 if value != nil { 4994 jtv, ok := value.(string) 4995 if !ok { 4996 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 4997 } 4998 sv.ExceptionMessage = ptr.String(jtv) 4999 } 5000 5001 default: 5002 _, _ = key, value 5003 5004 } 5005 } 5006 *v = sv 5007 return nil 5008} 5009 5010func awsRestjson1_deserializeDocumentStream(v **types.Stream, value interface{}) error { 5011 if v == nil { 5012 return fmt.Errorf("unexpected nil of type %T", v) 5013 } 5014 if value == nil { 5015 return nil 5016 } 5017 5018 shape, ok := value.(map[string]interface{}) 5019 if !ok { 5020 return fmt.Errorf("unexpected JSON type %v", value) 5021 } 5022 5023 var sv *types.Stream 5024 if *v == nil { 5025 sv = &types.Stream{} 5026 } else { 5027 sv = *v 5028 } 5029 5030 for key, value := range shape { 5031 switch key { 5032 case "channelArn": 5033 if value != nil { 5034 jtv, ok := value.(string) 5035 if !ok { 5036 return fmt.Errorf("expected ChannelArn to be of type string, got %T instead", value) 5037 } 5038 sv.ChannelArn = ptr.String(jtv) 5039 } 5040 5041 case "health": 5042 if value != nil { 5043 jtv, ok := value.(string) 5044 if !ok { 5045 return fmt.Errorf("expected StreamHealth to be of type string, got %T instead", value) 5046 } 5047 sv.Health = types.StreamHealth(jtv) 5048 } 5049 5050 case "playbackUrl": 5051 if value != nil { 5052 jtv, ok := value.(string) 5053 if !ok { 5054 return fmt.Errorf("expected PlaybackURL to be of type string, got %T instead", value) 5055 } 5056 sv.PlaybackUrl = ptr.String(jtv) 5057 } 5058 5059 case "startTime": 5060 if value != nil { 5061 jtv, ok := value.(string) 5062 if !ok { 5063 return fmt.Errorf("expected StreamStartTime to be of type string, got %T instead", value) 5064 } 5065 t, err := smithytime.ParseDateTime(jtv) 5066 if err != nil { 5067 return err 5068 } 5069 sv.StartTime = ptr.Time(t) 5070 } 5071 5072 case "state": 5073 if value != nil { 5074 jtv, ok := value.(string) 5075 if !ok { 5076 return fmt.Errorf("expected StreamState to be of type string, got %T instead", value) 5077 } 5078 sv.State = types.StreamState(jtv) 5079 } 5080 5081 case "viewerCount": 5082 if value != nil { 5083 jtv, ok := value.(json.Number) 5084 if !ok { 5085 return fmt.Errorf("expected StreamViewerCount to be json.Number, got %T instead", value) 5086 } 5087 i64, err := jtv.Int64() 5088 if err != nil { 5089 return err 5090 } 5091 sv.ViewerCount = i64 5092 } 5093 5094 default: 5095 _, _ = key, value 5096 5097 } 5098 } 5099 *v = sv 5100 return nil 5101} 5102 5103func awsRestjson1_deserializeDocumentStreamKey(v **types.StreamKey, value interface{}) error { 5104 if v == nil { 5105 return fmt.Errorf("unexpected nil of type %T", v) 5106 } 5107 if value == nil { 5108 return nil 5109 } 5110 5111 shape, ok := value.(map[string]interface{}) 5112 if !ok { 5113 return fmt.Errorf("unexpected JSON type %v", value) 5114 } 5115 5116 var sv *types.StreamKey 5117 if *v == nil { 5118 sv = &types.StreamKey{} 5119 } else { 5120 sv = *v 5121 } 5122 5123 for key, value := range shape { 5124 switch key { 5125 case "arn": 5126 if value != nil { 5127 jtv, ok := value.(string) 5128 if !ok { 5129 return fmt.Errorf("expected StreamKeyArn to be of type string, got %T instead", value) 5130 } 5131 sv.Arn = ptr.String(jtv) 5132 } 5133 5134 case "channelArn": 5135 if value != nil { 5136 jtv, ok := value.(string) 5137 if !ok { 5138 return fmt.Errorf("expected ChannelArn to be of type string, got %T instead", value) 5139 } 5140 sv.ChannelArn = ptr.String(jtv) 5141 } 5142 5143 case "tags": 5144 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 5145 return err 5146 } 5147 5148 case "value": 5149 if value != nil { 5150 jtv, ok := value.(string) 5151 if !ok { 5152 return fmt.Errorf("expected StreamKeyValue to be of type string, got %T instead", value) 5153 } 5154 sv.Value = ptr.String(jtv) 5155 } 5156 5157 default: 5158 _, _ = key, value 5159 5160 } 5161 } 5162 *v = sv 5163 return nil 5164} 5165 5166func awsRestjson1_deserializeDocumentStreamKeyList(v *[]types.StreamKeySummary, value interface{}) error { 5167 if v == nil { 5168 return fmt.Errorf("unexpected nil of type %T", v) 5169 } 5170 if value == nil { 5171 return nil 5172 } 5173 5174 shape, ok := value.([]interface{}) 5175 if !ok { 5176 return fmt.Errorf("unexpected JSON type %v", value) 5177 } 5178 5179 var cv []types.StreamKeySummary 5180 if *v == nil { 5181 cv = []types.StreamKeySummary{} 5182 } else { 5183 cv = *v 5184 } 5185 5186 for _, value := range shape { 5187 var col types.StreamKeySummary 5188 destAddr := &col 5189 if err := awsRestjson1_deserializeDocumentStreamKeySummary(&destAddr, value); err != nil { 5190 return err 5191 } 5192 col = *destAddr 5193 cv = append(cv, col) 5194 5195 } 5196 *v = cv 5197 return nil 5198} 5199 5200func awsRestjson1_deserializeDocumentStreamKeys(v *[]types.StreamKey, value interface{}) error { 5201 if v == nil { 5202 return fmt.Errorf("unexpected nil of type %T", v) 5203 } 5204 if value == nil { 5205 return nil 5206 } 5207 5208 shape, ok := value.([]interface{}) 5209 if !ok { 5210 return fmt.Errorf("unexpected JSON type %v", value) 5211 } 5212 5213 var cv []types.StreamKey 5214 if *v == nil { 5215 cv = []types.StreamKey{} 5216 } else { 5217 cv = *v 5218 } 5219 5220 for _, value := range shape { 5221 var col types.StreamKey 5222 destAddr := &col 5223 if err := awsRestjson1_deserializeDocumentStreamKey(&destAddr, value); err != nil { 5224 return err 5225 } 5226 col = *destAddr 5227 cv = append(cv, col) 5228 5229 } 5230 *v = cv 5231 return nil 5232} 5233 5234func awsRestjson1_deserializeDocumentStreamKeySummary(v **types.StreamKeySummary, value interface{}) error { 5235 if v == nil { 5236 return fmt.Errorf("unexpected nil of type %T", v) 5237 } 5238 if value == nil { 5239 return nil 5240 } 5241 5242 shape, ok := value.(map[string]interface{}) 5243 if !ok { 5244 return fmt.Errorf("unexpected JSON type %v", value) 5245 } 5246 5247 var sv *types.StreamKeySummary 5248 if *v == nil { 5249 sv = &types.StreamKeySummary{} 5250 } else { 5251 sv = *v 5252 } 5253 5254 for key, value := range shape { 5255 switch key { 5256 case "arn": 5257 if value != nil { 5258 jtv, ok := value.(string) 5259 if !ok { 5260 return fmt.Errorf("expected StreamKeyArn to be of type string, got %T instead", value) 5261 } 5262 sv.Arn = ptr.String(jtv) 5263 } 5264 5265 case "channelArn": 5266 if value != nil { 5267 jtv, ok := value.(string) 5268 if !ok { 5269 return fmt.Errorf("expected ChannelArn to be of type string, got %T instead", value) 5270 } 5271 sv.ChannelArn = ptr.String(jtv) 5272 } 5273 5274 case "tags": 5275 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 5276 return err 5277 } 5278 5279 default: 5280 _, _ = key, value 5281 5282 } 5283 } 5284 *v = sv 5285 return nil 5286} 5287 5288func awsRestjson1_deserializeDocumentStreamList(v *[]types.StreamSummary, value interface{}) error { 5289 if v == nil { 5290 return fmt.Errorf("unexpected nil of type %T", v) 5291 } 5292 if value == nil { 5293 return nil 5294 } 5295 5296 shape, ok := value.([]interface{}) 5297 if !ok { 5298 return fmt.Errorf("unexpected JSON type %v", value) 5299 } 5300 5301 var cv []types.StreamSummary 5302 if *v == nil { 5303 cv = []types.StreamSummary{} 5304 } else { 5305 cv = *v 5306 } 5307 5308 for _, value := range shape { 5309 var col types.StreamSummary 5310 destAddr := &col 5311 if err := awsRestjson1_deserializeDocumentStreamSummary(&destAddr, value); err != nil { 5312 return err 5313 } 5314 col = *destAddr 5315 cv = append(cv, col) 5316 5317 } 5318 *v = cv 5319 return nil 5320} 5321 5322func awsRestjson1_deserializeDocumentStreamSummary(v **types.StreamSummary, value interface{}) error { 5323 if v == nil { 5324 return fmt.Errorf("unexpected nil of type %T", v) 5325 } 5326 if value == nil { 5327 return nil 5328 } 5329 5330 shape, ok := value.(map[string]interface{}) 5331 if !ok { 5332 return fmt.Errorf("unexpected JSON type %v", value) 5333 } 5334 5335 var sv *types.StreamSummary 5336 if *v == nil { 5337 sv = &types.StreamSummary{} 5338 } else { 5339 sv = *v 5340 } 5341 5342 for key, value := range shape { 5343 switch key { 5344 case "channelArn": 5345 if value != nil { 5346 jtv, ok := value.(string) 5347 if !ok { 5348 return fmt.Errorf("expected ChannelArn to be of type string, got %T instead", value) 5349 } 5350 sv.ChannelArn = ptr.String(jtv) 5351 } 5352 5353 case "health": 5354 if value != nil { 5355 jtv, ok := value.(string) 5356 if !ok { 5357 return fmt.Errorf("expected StreamHealth to be of type string, got %T instead", value) 5358 } 5359 sv.Health = types.StreamHealth(jtv) 5360 } 5361 5362 case "startTime": 5363 if value != nil { 5364 jtv, ok := value.(string) 5365 if !ok { 5366 return fmt.Errorf("expected StreamStartTime to be of type string, got %T instead", value) 5367 } 5368 t, err := smithytime.ParseDateTime(jtv) 5369 if err != nil { 5370 return err 5371 } 5372 sv.StartTime = ptr.Time(t) 5373 } 5374 5375 case "state": 5376 if value != nil { 5377 jtv, ok := value.(string) 5378 if !ok { 5379 return fmt.Errorf("expected StreamState to be of type string, got %T instead", value) 5380 } 5381 sv.State = types.StreamState(jtv) 5382 } 5383 5384 case "viewerCount": 5385 if value != nil { 5386 jtv, ok := value.(json.Number) 5387 if !ok { 5388 return fmt.Errorf("expected StreamViewerCount to be json.Number, got %T instead", value) 5389 } 5390 i64, err := jtv.Int64() 5391 if err != nil { 5392 return err 5393 } 5394 sv.ViewerCount = i64 5395 } 5396 5397 default: 5398 _, _ = key, value 5399 5400 } 5401 } 5402 *v = sv 5403 return nil 5404} 5405 5406func awsRestjson1_deserializeDocumentStreamUnavailable(v **types.StreamUnavailable, value interface{}) error { 5407 if v == nil { 5408 return fmt.Errorf("unexpected nil of type %T", v) 5409 } 5410 if value == nil { 5411 return nil 5412 } 5413 5414 shape, ok := value.(map[string]interface{}) 5415 if !ok { 5416 return fmt.Errorf("unexpected JSON type %v", value) 5417 } 5418 5419 var sv *types.StreamUnavailable 5420 if *v == nil { 5421 sv = &types.StreamUnavailable{} 5422 } else { 5423 sv = *v 5424 } 5425 5426 for key, value := range shape { 5427 switch key { 5428 case "exceptionMessage": 5429 if value != nil { 5430 jtv, ok := value.(string) 5431 if !ok { 5432 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 5433 } 5434 sv.ExceptionMessage = ptr.String(jtv) 5435 } 5436 5437 default: 5438 _, _ = key, value 5439 5440 } 5441 } 5442 *v = sv 5443 return nil 5444} 5445 5446func awsRestjson1_deserializeDocumentTags(v *map[string]string, value interface{}) error { 5447 if v == nil { 5448 return fmt.Errorf("unexpected nil of type %T", v) 5449 } 5450 if value == nil { 5451 return nil 5452 } 5453 5454 shape, ok := value.(map[string]interface{}) 5455 if !ok { 5456 return fmt.Errorf("unexpected JSON type %v", value) 5457 } 5458 5459 var mv map[string]string 5460 if *v == nil { 5461 mv = map[string]string{} 5462 } else { 5463 mv = *v 5464 } 5465 5466 for key, value := range shape { 5467 var parsedVal string 5468 if value != nil { 5469 jtv, ok := value.(string) 5470 if !ok { 5471 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 5472 } 5473 parsedVal = jtv 5474 } 5475 mv[key] = parsedVal 5476 5477 } 5478 *v = mv 5479 return nil 5480} 5481 5482func awsRestjson1_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 5483 if v == nil { 5484 return fmt.Errorf("unexpected nil of type %T", v) 5485 } 5486 if value == nil { 5487 return nil 5488 } 5489 5490 shape, ok := value.(map[string]interface{}) 5491 if !ok { 5492 return fmt.Errorf("unexpected JSON type %v", value) 5493 } 5494 5495 var sv *types.ThrottlingException 5496 if *v == nil { 5497 sv = &types.ThrottlingException{} 5498 } else { 5499 sv = *v 5500 } 5501 5502 for key, value := range shape { 5503 switch key { 5504 case "exceptionMessage": 5505 if value != nil { 5506 jtv, ok := value.(string) 5507 if !ok { 5508 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 5509 } 5510 sv.ExceptionMessage = ptr.String(jtv) 5511 } 5512 5513 default: 5514 _, _ = key, value 5515 5516 } 5517 } 5518 *v = sv 5519 return nil 5520} 5521 5522func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 5523 if v == nil { 5524 return fmt.Errorf("unexpected nil of type %T", v) 5525 } 5526 if value == nil { 5527 return nil 5528 } 5529 5530 shape, ok := value.(map[string]interface{}) 5531 if !ok { 5532 return fmt.Errorf("unexpected JSON type %v", value) 5533 } 5534 5535 var sv *types.ValidationException 5536 if *v == nil { 5537 sv = &types.ValidationException{} 5538 } else { 5539 sv = *v 5540 } 5541 5542 for key, value := range shape { 5543 switch key { 5544 case "exceptionMessage": 5545 if value != nil { 5546 jtv, ok := value.(string) 5547 if !ok { 5548 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 5549 } 5550 sv.ExceptionMessage = ptr.String(jtv) 5551 } 5552 5553 default: 5554 _, _ = key, value 5555 5556 } 5557 } 5558 *v = sv 5559 return nil 5560} 5561