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