1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package mediastoredata 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/mediastoredata/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 "strconv" 20 "strings" 21) 22 23type awsRestjson1_deserializeOpDeleteObject struct { 24} 25 26func (*awsRestjson1_deserializeOpDeleteObject) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsRestjson1_deserializeOpDeleteObject) 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_deserializeOpErrorDeleteObject(response, &metadata) 45 } 46 output := &DeleteObjectOutput{} 47 out.Result = output 48 49 return out, metadata, err 50} 51 52func awsRestjson1_deserializeOpErrorDeleteObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 53 var errorBuffer bytes.Buffer 54 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 55 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 56 } 57 errorBody := bytes.NewReader(errorBuffer.Bytes()) 58 59 errorCode := "UnknownError" 60 errorMessage := errorCode 61 62 code := response.Header.Get("X-Amzn-ErrorType") 63 if len(code) != 0 { 64 errorCode = restjson.SanitizeErrorCode(code) 65 } 66 67 var buff [1024]byte 68 ringBuffer := smithyio.NewRingBuffer(buff[:]) 69 70 body := io.TeeReader(errorBody, ringBuffer) 71 decoder := json.NewDecoder(body) 72 decoder.UseNumber() 73 code, message, err := restjson.GetErrorInfo(decoder) 74 if err != nil { 75 var snapshot bytes.Buffer 76 io.Copy(&snapshot, ringBuffer) 77 err = &smithy.DeserializationError{ 78 Err: fmt.Errorf("failed to decode response body, %w", err), 79 Snapshot: snapshot.Bytes(), 80 } 81 return err 82 } 83 84 errorBody.Seek(0, io.SeekStart) 85 if len(code) != 0 { 86 errorCode = restjson.SanitizeErrorCode(code) 87 } 88 if len(message) != 0 { 89 errorMessage = message 90 } 91 92 switch { 93 case strings.EqualFold("ContainerNotFoundException", errorCode): 94 return awsRestjson1_deserializeErrorContainerNotFoundException(response, errorBody) 95 96 case strings.EqualFold("InternalServerError", errorCode): 97 return awsRestjson1_deserializeErrorInternalServerError(response, errorBody) 98 99 case strings.EqualFold("ObjectNotFoundException", errorCode): 100 return awsRestjson1_deserializeErrorObjectNotFoundException(response, errorBody) 101 102 default: 103 genericError := &smithy.GenericAPIError{ 104 Code: errorCode, 105 Message: errorMessage, 106 } 107 return genericError 108 109 } 110} 111 112type awsRestjson1_deserializeOpDescribeObject struct { 113} 114 115func (*awsRestjson1_deserializeOpDescribeObject) ID() string { 116 return "OperationDeserializer" 117} 118 119func (m *awsRestjson1_deserializeOpDescribeObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 120 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 121) { 122 out, metadata, err = next.HandleDeserialize(ctx, in) 123 if err != nil { 124 return out, metadata, err 125 } 126 127 response, ok := out.RawResponse.(*smithyhttp.Response) 128 if !ok { 129 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 130 } 131 132 if response.StatusCode < 200 || response.StatusCode >= 300 { 133 return out, metadata, awsRestjson1_deserializeOpErrorDescribeObject(response, &metadata) 134 } 135 output := &DescribeObjectOutput{} 136 out.Result = output 137 138 err = awsRestjson1_deserializeOpHttpBindingsDescribeObjectOutput(output, response) 139 if err != nil { 140 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 141 } 142 143 return out, metadata, err 144} 145 146func awsRestjson1_deserializeOpErrorDescribeObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 147 var errorBuffer bytes.Buffer 148 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 149 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 150 } 151 errorBody := bytes.NewReader(errorBuffer.Bytes()) 152 153 errorCode := "UnknownError" 154 errorMessage := errorCode 155 156 code := response.Header.Get("X-Amzn-ErrorType") 157 if len(code) != 0 { 158 errorCode = restjson.SanitizeErrorCode(code) 159 } 160 161 var buff [1024]byte 162 ringBuffer := smithyio.NewRingBuffer(buff[:]) 163 164 body := io.TeeReader(errorBody, ringBuffer) 165 decoder := json.NewDecoder(body) 166 decoder.UseNumber() 167 code, message, err := restjson.GetErrorInfo(decoder) 168 if err != nil { 169 var snapshot bytes.Buffer 170 io.Copy(&snapshot, ringBuffer) 171 err = &smithy.DeserializationError{ 172 Err: fmt.Errorf("failed to decode response body, %w", err), 173 Snapshot: snapshot.Bytes(), 174 } 175 return err 176 } 177 178 errorBody.Seek(0, io.SeekStart) 179 if len(code) != 0 { 180 errorCode = restjson.SanitizeErrorCode(code) 181 } 182 if len(message) != 0 { 183 errorMessage = message 184 } 185 186 switch { 187 case strings.EqualFold("ContainerNotFoundException", errorCode): 188 return awsRestjson1_deserializeErrorContainerNotFoundException(response, errorBody) 189 190 case strings.EqualFold("InternalServerError", errorCode): 191 return awsRestjson1_deserializeErrorInternalServerError(response, errorBody) 192 193 case strings.EqualFold("ObjectNotFoundException", errorCode): 194 return awsRestjson1_deserializeErrorObjectNotFoundException(response, errorBody) 195 196 default: 197 genericError := &smithy.GenericAPIError{ 198 Code: errorCode, 199 Message: errorMessage, 200 } 201 return genericError 202 203 } 204} 205 206func awsRestjson1_deserializeOpHttpBindingsDescribeObjectOutput(v *DescribeObjectOutput, response *smithyhttp.Response) error { 207 if v == nil { 208 return fmt.Errorf("unsupported deserialization for nil %T", v) 209 } 210 211 if headerValues := response.Header.Values("Cache-Control"); len(headerValues) != 0 { 212 headerValues[0] = strings.TrimSpace(headerValues[0]) 213 v.CacheControl = ptr.String(headerValues[0]) 214 } 215 216 if headerValues := response.Header.Values("Content-Length"); len(headerValues) != 0 { 217 headerValues[0] = strings.TrimSpace(headerValues[0]) 218 vv, err := strconv.ParseInt(headerValues[0], 0, 64) 219 if err != nil { 220 return err 221 } 222 v.ContentLength = ptr.Int64(vv) 223 } 224 225 if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 { 226 headerValues[0] = strings.TrimSpace(headerValues[0]) 227 v.ContentType = ptr.String(headerValues[0]) 228 } 229 230 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 231 headerValues[0] = strings.TrimSpace(headerValues[0]) 232 v.ETag = ptr.String(headerValues[0]) 233 } 234 235 if headerValues := response.Header.Values("Last-Modified"); len(headerValues) != 0 { 236 headerValues[0] = strings.TrimSpace(headerValues[0]) 237 t, err := smithytime.ParseHTTPDate(headerValues[0]) 238 if err != nil { 239 return err 240 } 241 v.LastModified = ptr.Time(t) 242 } 243 244 return nil 245} 246 247type awsRestjson1_deserializeOpGetObject struct { 248} 249 250func (*awsRestjson1_deserializeOpGetObject) ID() string { 251 return "OperationDeserializer" 252} 253 254func (m *awsRestjson1_deserializeOpGetObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 255 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 256) { 257 out, metadata, err = next.HandleDeserialize(ctx, in) 258 if err != nil { 259 return out, metadata, err 260 } 261 262 response, ok := out.RawResponse.(*smithyhttp.Response) 263 if !ok { 264 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 265 } 266 267 if response.StatusCode < 200 || response.StatusCode >= 300 { 268 return out, metadata, awsRestjson1_deserializeOpErrorGetObject(response, &metadata) 269 } 270 output := &GetObjectOutput{} 271 out.Result = output 272 273 err = awsRestjson1_deserializeOpHttpBindingsGetObjectOutput(output, response) 274 if err != nil { 275 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 276 } 277 278 err = awsRestjson1_deserializeOpDocumentGetObjectOutput(output, response.Body) 279 if err != nil { 280 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 281 } 282 283 return out, metadata, err 284} 285 286func awsRestjson1_deserializeOpErrorGetObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 287 var errorBuffer bytes.Buffer 288 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 289 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 290 } 291 errorBody := bytes.NewReader(errorBuffer.Bytes()) 292 293 errorCode := "UnknownError" 294 errorMessage := errorCode 295 296 code := response.Header.Get("X-Amzn-ErrorType") 297 if len(code) != 0 { 298 errorCode = restjson.SanitizeErrorCode(code) 299 } 300 301 var buff [1024]byte 302 ringBuffer := smithyio.NewRingBuffer(buff[:]) 303 304 body := io.TeeReader(errorBody, ringBuffer) 305 decoder := json.NewDecoder(body) 306 decoder.UseNumber() 307 code, message, err := restjson.GetErrorInfo(decoder) 308 if err != nil { 309 var snapshot bytes.Buffer 310 io.Copy(&snapshot, ringBuffer) 311 err = &smithy.DeserializationError{ 312 Err: fmt.Errorf("failed to decode response body, %w", err), 313 Snapshot: snapshot.Bytes(), 314 } 315 return err 316 } 317 318 errorBody.Seek(0, io.SeekStart) 319 if len(code) != 0 { 320 errorCode = restjson.SanitizeErrorCode(code) 321 } 322 if len(message) != 0 { 323 errorMessage = message 324 } 325 326 switch { 327 case strings.EqualFold("ContainerNotFoundException", errorCode): 328 return awsRestjson1_deserializeErrorContainerNotFoundException(response, errorBody) 329 330 case strings.EqualFold("InternalServerError", errorCode): 331 return awsRestjson1_deserializeErrorInternalServerError(response, errorBody) 332 333 case strings.EqualFold("ObjectNotFoundException", errorCode): 334 return awsRestjson1_deserializeErrorObjectNotFoundException(response, errorBody) 335 336 case strings.EqualFold("RequestedRangeNotSatisfiableException", errorCode): 337 return awsRestjson1_deserializeErrorRequestedRangeNotSatisfiableException(response, errorBody) 338 339 default: 340 genericError := &smithy.GenericAPIError{ 341 Code: errorCode, 342 Message: errorMessage, 343 } 344 return genericError 345 346 } 347} 348 349func awsRestjson1_deserializeOpHttpBindingsGetObjectOutput(v *GetObjectOutput, response *smithyhttp.Response) error { 350 if v == nil { 351 return fmt.Errorf("unsupported deserialization for nil %T", v) 352 } 353 354 if headerValues := response.Header.Values("Cache-Control"); len(headerValues) != 0 { 355 headerValues[0] = strings.TrimSpace(headerValues[0]) 356 v.CacheControl = ptr.String(headerValues[0]) 357 } 358 359 if headerValues := response.Header.Values("Content-Length"); len(headerValues) != 0 { 360 headerValues[0] = strings.TrimSpace(headerValues[0]) 361 vv, err := strconv.ParseInt(headerValues[0], 0, 64) 362 if err != nil { 363 return err 364 } 365 v.ContentLength = ptr.Int64(vv) 366 } 367 368 if headerValues := response.Header.Values("Content-Range"); len(headerValues) != 0 { 369 headerValues[0] = strings.TrimSpace(headerValues[0]) 370 v.ContentRange = ptr.String(headerValues[0]) 371 } 372 373 if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 { 374 headerValues[0] = strings.TrimSpace(headerValues[0]) 375 v.ContentType = ptr.String(headerValues[0]) 376 } 377 378 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 379 headerValues[0] = strings.TrimSpace(headerValues[0]) 380 v.ETag = ptr.String(headerValues[0]) 381 } 382 383 if headerValues := response.Header.Values("Last-Modified"); len(headerValues) != 0 { 384 headerValues[0] = strings.TrimSpace(headerValues[0]) 385 t, err := smithytime.ParseHTTPDate(headerValues[0]) 386 if err != nil { 387 return err 388 } 389 v.LastModified = ptr.Time(t) 390 } 391 392 v.StatusCode = int32(response.StatusCode) 393 394 return nil 395} 396func awsRestjson1_deserializeOpDocumentGetObjectOutput(v *GetObjectOutput, body io.ReadCloser) error { 397 if v == nil { 398 return fmt.Errorf("unsupported deserialization of nil %T", v) 399 } 400 401 v.Body = body 402 return nil 403} 404 405type awsRestjson1_deserializeOpListItems struct { 406} 407 408func (*awsRestjson1_deserializeOpListItems) ID() string { 409 return "OperationDeserializer" 410} 411 412func (m *awsRestjson1_deserializeOpListItems) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 413 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 414) { 415 out, metadata, err = next.HandleDeserialize(ctx, in) 416 if err != nil { 417 return out, metadata, err 418 } 419 420 response, ok := out.RawResponse.(*smithyhttp.Response) 421 if !ok { 422 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 423 } 424 425 if response.StatusCode < 200 || response.StatusCode >= 300 { 426 return out, metadata, awsRestjson1_deserializeOpErrorListItems(response, &metadata) 427 } 428 output := &ListItemsOutput{} 429 out.Result = output 430 431 var buff [1024]byte 432 ringBuffer := smithyio.NewRingBuffer(buff[:]) 433 434 body := io.TeeReader(response.Body, ringBuffer) 435 436 decoder := json.NewDecoder(body) 437 decoder.UseNumber() 438 var shape interface{} 439 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 440 var snapshot bytes.Buffer 441 io.Copy(&snapshot, ringBuffer) 442 err = &smithy.DeserializationError{ 443 Err: fmt.Errorf("failed to decode response body, %w", err), 444 Snapshot: snapshot.Bytes(), 445 } 446 return out, metadata, err 447 } 448 449 err = awsRestjson1_deserializeOpDocumentListItemsOutput(&output, shape) 450 if err != nil { 451 var snapshot bytes.Buffer 452 io.Copy(&snapshot, ringBuffer) 453 return out, metadata, &smithy.DeserializationError{ 454 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 455 Snapshot: snapshot.Bytes(), 456 } 457 } 458 459 return out, metadata, err 460} 461 462func awsRestjson1_deserializeOpErrorListItems(response *smithyhttp.Response, metadata *middleware.Metadata) error { 463 var errorBuffer bytes.Buffer 464 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 465 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 466 } 467 errorBody := bytes.NewReader(errorBuffer.Bytes()) 468 469 errorCode := "UnknownError" 470 errorMessage := errorCode 471 472 code := response.Header.Get("X-Amzn-ErrorType") 473 if len(code) != 0 { 474 errorCode = restjson.SanitizeErrorCode(code) 475 } 476 477 var buff [1024]byte 478 ringBuffer := smithyio.NewRingBuffer(buff[:]) 479 480 body := io.TeeReader(errorBody, ringBuffer) 481 decoder := json.NewDecoder(body) 482 decoder.UseNumber() 483 code, message, err := restjson.GetErrorInfo(decoder) 484 if err != nil { 485 var snapshot bytes.Buffer 486 io.Copy(&snapshot, ringBuffer) 487 err = &smithy.DeserializationError{ 488 Err: fmt.Errorf("failed to decode response body, %w", err), 489 Snapshot: snapshot.Bytes(), 490 } 491 return err 492 } 493 494 errorBody.Seek(0, io.SeekStart) 495 if len(code) != 0 { 496 errorCode = restjson.SanitizeErrorCode(code) 497 } 498 if len(message) != 0 { 499 errorMessage = message 500 } 501 502 switch { 503 case strings.EqualFold("ContainerNotFoundException", errorCode): 504 return awsRestjson1_deserializeErrorContainerNotFoundException(response, errorBody) 505 506 case strings.EqualFold("InternalServerError", errorCode): 507 return awsRestjson1_deserializeErrorInternalServerError(response, errorBody) 508 509 default: 510 genericError := &smithy.GenericAPIError{ 511 Code: errorCode, 512 Message: errorMessage, 513 } 514 return genericError 515 516 } 517} 518 519func awsRestjson1_deserializeOpDocumentListItemsOutput(v **ListItemsOutput, value interface{}) error { 520 if v == nil { 521 return fmt.Errorf("unexpected nil of type %T", v) 522 } 523 if value == nil { 524 return nil 525 } 526 527 shape, ok := value.(map[string]interface{}) 528 if !ok { 529 return fmt.Errorf("unexpected JSON type %v", value) 530 } 531 532 var sv *ListItemsOutput 533 if *v == nil { 534 sv = &ListItemsOutput{} 535 } else { 536 sv = *v 537 } 538 539 for key, value := range shape { 540 switch key { 541 case "Items": 542 if err := awsRestjson1_deserializeDocumentItemList(&sv.Items, value); err != nil { 543 return err 544 } 545 546 case "NextToken": 547 if value != nil { 548 jtv, ok := value.(string) 549 if !ok { 550 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 551 } 552 sv.NextToken = ptr.String(jtv) 553 } 554 555 default: 556 _, _ = key, value 557 558 } 559 } 560 *v = sv 561 return nil 562} 563 564type awsRestjson1_deserializeOpPutObject struct { 565} 566 567func (*awsRestjson1_deserializeOpPutObject) ID() string { 568 return "OperationDeserializer" 569} 570 571func (m *awsRestjson1_deserializeOpPutObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 572 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 573) { 574 out, metadata, err = next.HandleDeserialize(ctx, in) 575 if err != nil { 576 return out, metadata, err 577 } 578 579 response, ok := out.RawResponse.(*smithyhttp.Response) 580 if !ok { 581 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 582 } 583 584 if response.StatusCode < 200 || response.StatusCode >= 300 { 585 return out, metadata, awsRestjson1_deserializeOpErrorPutObject(response, &metadata) 586 } 587 output := &PutObjectOutput{} 588 out.Result = output 589 590 var buff [1024]byte 591 ringBuffer := smithyio.NewRingBuffer(buff[:]) 592 593 body := io.TeeReader(response.Body, ringBuffer) 594 595 decoder := json.NewDecoder(body) 596 decoder.UseNumber() 597 var shape interface{} 598 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 599 var snapshot bytes.Buffer 600 io.Copy(&snapshot, ringBuffer) 601 err = &smithy.DeserializationError{ 602 Err: fmt.Errorf("failed to decode response body, %w", err), 603 Snapshot: snapshot.Bytes(), 604 } 605 return out, metadata, err 606 } 607 608 err = awsRestjson1_deserializeOpDocumentPutObjectOutput(&output, shape) 609 if err != nil { 610 var snapshot bytes.Buffer 611 io.Copy(&snapshot, ringBuffer) 612 return out, metadata, &smithy.DeserializationError{ 613 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 614 Snapshot: snapshot.Bytes(), 615 } 616 } 617 618 return out, metadata, err 619} 620 621func awsRestjson1_deserializeOpErrorPutObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 622 var errorBuffer bytes.Buffer 623 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 624 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 625 } 626 errorBody := bytes.NewReader(errorBuffer.Bytes()) 627 628 errorCode := "UnknownError" 629 errorMessage := errorCode 630 631 code := response.Header.Get("X-Amzn-ErrorType") 632 if len(code) != 0 { 633 errorCode = restjson.SanitizeErrorCode(code) 634 } 635 636 var buff [1024]byte 637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 638 639 body := io.TeeReader(errorBody, ringBuffer) 640 decoder := json.NewDecoder(body) 641 decoder.UseNumber() 642 code, message, err := restjson.GetErrorInfo(decoder) 643 if err != nil { 644 var snapshot bytes.Buffer 645 io.Copy(&snapshot, ringBuffer) 646 err = &smithy.DeserializationError{ 647 Err: fmt.Errorf("failed to decode response body, %w", err), 648 Snapshot: snapshot.Bytes(), 649 } 650 return err 651 } 652 653 errorBody.Seek(0, io.SeekStart) 654 if len(code) != 0 { 655 errorCode = restjson.SanitizeErrorCode(code) 656 } 657 if len(message) != 0 { 658 errorMessage = message 659 } 660 661 switch { 662 case strings.EqualFold("ContainerNotFoundException", errorCode): 663 return awsRestjson1_deserializeErrorContainerNotFoundException(response, errorBody) 664 665 case strings.EqualFold("InternalServerError", errorCode): 666 return awsRestjson1_deserializeErrorInternalServerError(response, errorBody) 667 668 default: 669 genericError := &smithy.GenericAPIError{ 670 Code: errorCode, 671 Message: errorMessage, 672 } 673 return genericError 674 675 } 676} 677 678func awsRestjson1_deserializeOpDocumentPutObjectOutput(v **PutObjectOutput, value interface{}) error { 679 if v == nil { 680 return fmt.Errorf("unexpected nil of type %T", v) 681 } 682 if value == nil { 683 return nil 684 } 685 686 shape, ok := value.(map[string]interface{}) 687 if !ok { 688 return fmt.Errorf("unexpected JSON type %v", value) 689 } 690 691 var sv *PutObjectOutput 692 if *v == nil { 693 sv = &PutObjectOutput{} 694 } else { 695 sv = *v 696 } 697 698 for key, value := range shape { 699 switch key { 700 case "ContentSHA256": 701 if value != nil { 702 jtv, ok := value.(string) 703 if !ok { 704 return fmt.Errorf("expected SHA256Hash to be of type string, got %T instead", value) 705 } 706 sv.ContentSHA256 = ptr.String(jtv) 707 } 708 709 case "ETag": 710 if value != nil { 711 jtv, ok := value.(string) 712 if !ok { 713 return fmt.Errorf("expected ETag to be of type string, got %T instead", value) 714 } 715 sv.ETag = ptr.String(jtv) 716 } 717 718 case "StorageClass": 719 if value != nil { 720 jtv, ok := value.(string) 721 if !ok { 722 return fmt.Errorf("expected StorageClass to be of type string, got %T instead", value) 723 } 724 sv.StorageClass = types.StorageClass(jtv) 725 } 726 727 default: 728 _, _ = key, value 729 730 } 731 } 732 *v = sv 733 return nil 734} 735 736func awsRestjson1_deserializeErrorContainerNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 737 output := &types.ContainerNotFoundException{} 738 var buff [1024]byte 739 ringBuffer := smithyio.NewRingBuffer(buff[:]) 740 741 body := io.TeeReader(errorBody, ringBuffer) 742 decoder := json.NewDecoder(body) 743 decoder.UseNumber() 744 var shape interface{} 745 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 746 var snapshot bytes.Buffer 747 io.Copy(&snapshot, ringBuffer) 748 err = &smithy.DeserializationError{ 749 Err: fmt.Errorf("failed to decode response body, %w", err), 750 Snapshot: snapshot.Bytes(), 751 } 752 return err 753 } 754 755 err := awsRestjson1_deserializeDocumentContainerNotFoundException(&output, shape) 756 757 if err != nil { 758 var snapshot bytes.Buffer 759 io.Copy(&snapshot, ringBuffer) 760 err = &smithy.DeserializationError{ 761 Err: fmt.Errorf("failed to decode response body, %w", err), 762 Snapshot: snapshot.Bytes(), 763 } 764 return err 765 } 766 767 errorBody.Seek(0, io.SeekStart) 768 769 return output 770} 771 772func awsRestjson1_deserializeErrorInternalServerError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 773 output := &types.InternalServerError{} 774 var buff [1024]byte 775 ringBuffer := smithyio.NewRingBuffer(buff[:]) 776 777 body := io.TeeReader(errorBody, ringBuffer) 778 decoder := json.NewDecoder(body) 779 decoder.UseNumber() 780 var shape interface{} 781 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 782 var snapshot bytes.Buffer 783 io.Copy(&snapshot, ringBuffer) 784 err = &smithy.DeserializationError{ 785 Err: fmt.Errorf("failed to decode response body, %w", err), 786 Snapshot: snapshot.Bytes(), 787 } 788 return err 789 } 790 791 err := awsRestjson1_deserializeDocumentInternalServerError(&output, shape) 792 793 if err != nil { 794 var snapshot bytes.Buffer 795 io.Copy(&snapshot, ringBuffer) 796 err = &smithy.DeserializationError{ 797 Err: fmt.Errorf("failed to decode response body, %w", err), 798 Snapshot: snapshot.Bytes(), 799 } 800 return err 801 } 802 803 errorBody.Seek(0, io.SeekStart) 804 805 return output 806} 807 808func awsRestjson1_deserializeErrorObjectNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 809 output := &types.ObjectNotFoundException{} 810 var buff [1024]byte 811 ringBuffer := smithyio.NewRingBuffer(buff[:]) 812 813 body := io.TeeReader(errorBody, ringBuffer) 814 decoder := json.NewDecoder(body) 815 decoder.UseNumber() 816 var shape interface{} 817 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 818 var snapshot bytes.Buffer 819 io.Copy(&snapshot, ringBuffer) 820 err = &smithy.DeserializationError{ 821 Err: fmt.Errorf("failed to decode response body, %w", err), 822 Snapshot: snapshot.Bytes(), 823 } 824 return err 825 } 826 827 err := awsRestjson1_deserializeDocumentObjectNotFoundException(&output, shape) 828 829 if err != nil { 830 var snapshot bytes.Buffer 831 io.Copy(&snapshot, ringBuffer) 832 err = &smithy.DeserializationError{ 833 Err: fmt.Errorf("failed to decode response body, %w", err), 834 Snapshot: snapshot.Bytes(), 835 } 836 return err 837 } 838 839 errorBody.Seek(0, io.SeekStart) 840 841 return output 842} 843 844func awsRestjson1_deserializeErrorRequestedRangeNotSatisfiableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 845 output := &types.RequestedRangeNotSatisfiableException{} 846 var buff [1024]byte 847 ringBuffer := smithyio.NewRingBuffer(buff[:]) 848 849 body := io.TeeReader(errorBody, ringBuffer) 850 decoder := json.NewDecoder(body) 851 decoder.UseNumber() 852 var shape interface{} 853 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 854 var snapshot bytes.Buffer 855 io.Copy(&snapshot, ringBuffer) 856 err = &smithy.DeserializationError{ 857 Err: fmt.Errorf("failed to decode response body, %w", err), 858 Snapshot: snapshot.Bytes(), 859 } 860 return err 861 } 862 863 err := awsRestjson1_deserializeDocumentRequestedRangeNotSatisfiableException(&output, shape) 864 865 if err != nil { 866 var snapshot bytes.Buffer 867 io.Copy(&snapshot, ringBuffer) 868 err = &smithy.DeserializationError{ 869 Err: fmt.Errorf("failed to decode response body, %w", err), 870 Snapshot: snapshot.Bytes(), 871 } 872 return err 873 } 874 875 errorBody.Seek(0, io.SeekStart) 876 877 return output 878} 879 880func awsRestjson1_deserializeDocumentContainerNotFoundException(v **types.ContainerNotFoundException, value interface{}) error { 881 if v == nil { 882 return fmt.Errorf("unexpected nil of type %T", v) 883 } 884 if value == nil { 885 return nil 886 } 887 888 shape, ok := value.(map[string]interface{}) 889 if !ok { 890 return fmt.Errorf("unexpected JSON type %v", value) 891 } 892 893 var sv *types.ContainerNotFoundException 894 if *v == nil { 895 sv = &types.ContainerNotFoundException{} 896 } else { 897 sv = *v 898 } 899 900 for key, value := range shape { 901 switch key { 902 case "Message": 903 if value != nil { 904 jtv, ok := value.(string) 905 if !ok { 906 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 907 } 908 sv.Message = ptr.String(jtv) 909 } 910 911 default: 912 _, _ = key, value 913 914 } 915 } 916 *v = sv 917 return nil 918} 919 920func awsRestjson1_deserializeDocumentInternalServerError(v **types.InternalServerError, value interface{}) error { 921 if v == nil { 922 return fmt.Errorf("unexpected nil of type %T", v) 923 } 924 if value == nil { 925 return nil 926 } 927 928 shape, ok := value.(map[string]interface{}) 929 if !ok { 930 return fmt.Errorf("unexpected JSON type %v", value) 931 } 932 933 var sv *types.InternalServerError 934 if *v == nil { 935 sv = &types.InternalServerError{} 936 } else { 937 sv = *v 938 } 939 940 for key, value := range shape { 941 switch key { 942 case "Message": 943 if value != nil { 944 jtv, ok := value.(string) 945 if !ok { 946 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 947 } 948 sv.Message = ptr.String(jtv) 949 } 950 951 default: 952 _, _ = key, value 953 954 } 955 } 956 *v = sv 957 return nil 958} 959 960func awsRestjson1_deserializeDocumentItem(v **types.Item, value interface{}) error { 961 if v == nil { 962 return fmt.Errorf("unexpected nil of type %T", v) 963 } 964 if value == nil { 965 return nil 966 } 967 968 shape, ok := value.(map[string]interface{}) 969 if !ok { 970 return fmt.Errorf("unexpected JSON type %v", value) 971 } 972 973 var sv *types.Item 974 if *v == nil { 975 sv = &types.Item{} 976 } else { 977 sv = *v 978 } 979 980 for key, value := range shape { 981 switch key { 982 case "ContentLength": 983 if value != nil { 984 jtv, ok := value.(json.Number) 985 if !ok { 986 return fmt.Errorf("expected NonNegativeLong to be json.Number, got %T instead", value) 987 } 988 i64, err := jtv.Int64() 989 if err != nil { 990 return err 991 } 992 sv.ContentLength = ptr.Int64(i64) 993 } 994 995 case "ContentType": 996 if value != nil { 997 jtv, ok := value.(string) 998 if !ok { 999 return fmt.Errorf("expected ContentType to be of type string, got %T instead", value) 1000 } 1001 sv.ContentType = ptr.String(jtv) 1002 } 1003 1004 case "ETag": 1005 if value != nil { 1006 jtv, ok := value.(string) 1007 if !ok { 1008 return fmt.Errorf("expected ETag to be of type string, got %T instead", value) 1009 } 1010 sv.ETag = ptr.String(jtv) 1011 } 1012 1013 case "LastModified": 1014 if value != nil { 1015 jtv, ok := value.(json.Number) 1016 if !ok { 1017 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 1018 } 1019 f64, err := jtv.Float64() 1020 if err != nil { 1021 return err 1022 } 1023 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1024 } 1025 1026 case "Name": 1027 if value != nil { 1028 jtv, ok := value.(string) 1029 if !ok { 1030 return fmt.Errorf("expected ItemName to be of type string, got %T instead", value) 1031 } 1032 sv.Name = ptr.String(jtv) 1033 } 1034 1035 case "Type": 1036 if value != nil { 1037 jtv, ok := value.(string) 1038 if !ok { 1039 return fmt.Errorf("expected ItemType to be of type string, got %T instead", value) 1040 } 1041 sv.Type = types.ItemType(jtv) 1042 } 1043 1044 default: 1045 _, _ = key, value 1046 1047 } 1048 } 1049 *v = sv 1050 return nil 1051} 1052 1053func awsRestjson1_deserializeDocumentItemList(v *[]types.Item, value interface{}) error { 1054 if v == nil { 1055 return fmt.Errorf("unexpected nil of type %T", v) 1056 } 1057 if value == nil { 1058 return nil 1059 } 1060 1061 shape, ok := value.([]interface{}) 1062 if !ok { 1063 return fmt.Errorf("unexpected JSON type %v", value) 1064 } 1065 1066 var cv []types.Item 1067 if *v == nil { 1068 cv = []types.Item{} 1069 } else { 1070 cv = *v 1071 } 1072 1073 for _, value := range shape { 1074 var col types.Item 1075 destAddr := &col 1076 if err := awsRestjson1_deserializeDocumentItem(&destAddr, value); err != nil { 1077 return err 1078 } 1079 col = *destAddr 1080 cv = append(cv, col) 1081 1082 } 1083 *v = cv 1084 return nil 1085} 1086 1087func awsRestjson1_deserializeDocumentObjectNotFoundException(v **types.ObjectNotFoundException, value interface{}) error { 1088 if v == nil { 1089 return fmt.Errorf("unexpected nil of type %T", v) 1090 } 1091 if value == nil { 1092 return nil 1093 } 1094 1095 shape, ok := value.(map[string]interface{}) 1096 if !ok { 1097 return fmt.Errorf("unexpected JSON type %v", value) 1098 } 1099 1100 var sv *types.ObjectNotFoundException 1101 if *v == nil { 1102 sv = &types.ObjectNotFoundException{} 1103 } else { 1104 sv = *v 1105 } 1106 1107 for key, value := range shape { 1108 switch key { 1109 case "Message": 1110 if value != nil { 1111 jtv, ok := value.(string) 1112 if !ok { 1113 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 1114 } 1115 sv.Message = ptr.String(jtv) 1116 } 1117 1118 default: 1119 _, _ = key, value 1120 1121 } 1122 } 1123 *v = sv 1124 return nil 1125} 1126 1127func awsRestjson1_deserializeDocumentRequestedRangeNotSatisfiableException(v **types.RequestedRangeNotSatisfiableException, value interface{}) error { 1128 if v == nil { 1129 return fmt.Errorf("unexpected nil of type %T", v) 1130 } 1131 if value == nil { 1132 return nil 1133 } 1134 1135 shape, ok := value.(map[string]interface{}) 1136 if !ok { 1137 return fmt.Errorf("unexpected JSON type %v", value) 1138 } 1139 1140 var sv *types.RequestedRangeNotSatisfiableException 1141 if *v == nil { 1142 sv = &types.RequestedRangeNotSatisfiableException{} 1143 } else { 1144 sv = *v 1145 } 1146 1147 for key, value := range shape { 1148 switch key { 1149 case "Message": 1150 if value != nil { 1151 jtv, ok := value.(string) 1152 if !ok { 1153 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 1154 } 1155 sv.Message = ptr.String(jtv) 1156 } 1157 1158 default: 1159 _, _ = key, value 1160 1161 } 1162 } 1163 *v = sv 1164 return nil 1165} 1166