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