1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package lambda 4 5import ( 6 "bytes" 7 "context" 8 "encoding/json" 9 "fmt" 10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 11 "github.com/aws/aws-sdk-go-v2/service/lambda/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "io/ioutil" 20 "strings" 21) 22 23type awsRestjson1_deserializeOpAddLayerVersionPermission struct { 24} 25 26func (*awsRestjson1_deserializeOpAddLayerVersionPermission) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsRestjson1_deserializeOpAddLayerVersionPermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 32) { 33 out, metadata, err = next.HandleDeserialize(ctx, in) 34 if err != nil { 35 return out, metadata, err 36 } 37 38 response, ok := out.RawResponse.(*smithyhttp.Response) 39 if !ok { 40 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 41 } 42 43 if response.StatusCode < 200 || response.StatusCode >= 300 { 44 return out, metadata, awsRestjson1_deserializeOpErrorAddLayerVersionPermission(response, &metadata) 45 } 46 output := &AddLayerVersionPermissionOutput{} 47 out.Result = output 48 49 var buff [1024]byte 50 ringBuffer := smithyio.NewRingBuffer(buff[:]) 51 52 body := io.TeeReader(response.Body, ringBuffer) 53 54 decoder := json.NewDecoder(body) 55 decoder.UseNumber() 56 var shape interface{} 57 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 58 var snapshot bytes.Buffer 59 io.Copy(&snapshot, ringBuffer) 60 err = &smithy.DeserializationError{ 61 Err: fmt.Errorf("failed to decode response body, %w", err), 62 Snapshot: snapshot.Bytes(), 63 } 64 return out, metadata, err 65 } 66 67 err = awsRestjson1_deserializeOpDocumentAddLayerVersionPermissionOutput(&output, shape) 68 if err != nil { 69 var snapshot bytes.Buffer 70 io.Copy(&snapshot, ringBuffer) 71 return out, metadata, &smithy.DeserializationError{ 72 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 73 Snapshot: snapshot.Bytes(), 74 } 75 } 76 77 return out, metadata, err 78} 79 80func awsRestjson1_deserializeOpErrorAddLayerVersionPermission(response *smithyhttp.Response, metadata *middleware.Metadata) error { 81 var errorBuffer bytes.Buffer 82 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 83 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 84 } 85 errorBody := bytes.NewReader(errorBuffer.Bytes()) 86 87 errorCode := "UnknownError" 88 errorMessage := errorCode 89 90 code := response.Header.Get("X-Amzn-ErrorType") 91 if len(code) != 0 { 92 errorCode = restjson.SanitizeErrorCode(code) 93 } 94 95 var buff [1024]byte 96 ringBuffer := smithyio.NewRingBuffer(buff[:]) 97 98 body := io.TeeReader(errorBody, ringBuffer) 99 decoder := json.NewDecoder(body) 100 decoder.UseNumber() 101 code, message, err := restjson.GetErrorInfo(decoder) 102 if err != nil { 103 var snapshot bytes.Buffer 104 io.Copy(&snapshot, ringBuffer) 105 err = &smithy.DeserializationError{ 106 Err: fmt.Errorf("failed to decode response body, %w", err), 107 Snapshot: snapshot.Bytes(), 108 } 109 return err 110 } 111 112 errorBody.Seek(0, io.SeekStart) 113 if len(code) != 0 { 114 errorCode = restjson.SanitizeErrorCode(code) 115 } 116 if len(message) != 0 { 117 errorMessage = message 118 } 119 120 switch { 121 case strings.EqualFold("InvalidParameterValueException", errorCode): 122 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 123 124 case strings.EqualFold("PolicyLengthExceededException", errorCode): 125 return awsRestjson1_deserializeErrorPolicyLengthExceededException(response, errorBody) 126 127 case strings.EqualFold("PreconditionFailedException", errorCode): 128 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 129 130 case strings.EqualFold("ResourceConflictException", errorCode): 131 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 132 133 case strings.EqualFold("ResourceNotFoundException", errorCode): 134 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 135 136 case strings.EqualFold("ServiceException", errorCode): 137 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 138 139 case strings.EqualFold("TooManyRequestsException", errorCode): 140 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 141 142 default: 143 genericError := &smithy.GenericAPIError{ 144 Code: errorCode, 145 Message: errorMessage, 146 } 147 return genericError 148 149 } 150} 151 152func awsRestjson1_deserializeOpDocumentAddLayerVersionPermissionOutput(v **AddLayerVersionPermissionOutput, value interface{}) error { 153 if v == nil { 154 return fmt.Errorf("unexpected nil of type %T", v) 155 } 156 if value == nil { 157 return nil 158 } 159 160 shape, ok := value.(map[string]interface{}) 161 if !ok { 162 return fmt.Errorf("unexpected JSON type %v", value) 163 } 164 165 var sv *AddLayerVersionPermissionOutput 166 if *v == nil { 167 sv = &AddLayerVersionPermissionOutput{} 168 } else { 169 sv = *v 170 } 171 172 for key, value := range shape { 173 switch key { 174 case "RevisionId": 175 if value != nil { 176 jtv, ok := value.(string) 177 if !ok { 178 return fmt.Errorf("expected String to be of type string, got %T instead", value) 179 } 180 sv.RevisionId = ptr.String(jtv) 181 } 182 183 case "Statement": 184 if value != nil { 185 jtv, ok := value.(string) 186 if !ok { 187 return fmt.Errorf("expected String to be of type string, got %T instead", value) 188 } 189 sv.Statement = ptr.String(jtv) 190 } 191 192 default: 193 _, _ = key, value 194 195 } 196 } 197 *v = sv 198 return nil 199} 200 201type awsRestjson1_deserializeOpAddPermission struct { 202} 203 204func (*awsRestjson1_deserializeOpAddPermission) ID() string { 205 return "OperationDeserializer" 206} 207 208func (m *awsRestjson1_deserializeOpAddPermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 209 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 210) { 211 out, metadata, err = next.HandleDeserialize(ctx, in) 212 if err != nil { 213 return out, metadata, err 214 } 215 216 response, ok := out.RawResponse.(*smithyhttp.Response) 217 if !ok { 218 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 219 } 220 221 if response.StatusCode < 200 || response.StatusCode >= 300 { 222 return out, metadata, awsRestjson1_deserializeOpErrorAddPermission(response, &metadata) 223 } 224 output := &AddPermissionOutput{} 225 out.Result = output 226 227 var buff [1024]byte 228 ringBuffer := smithyio.NewRingBuffer(buff[:]) 229 230 body := io.TeeReader(response.Body, ringBuffer) 231 232 decoder := json.NewDecoder(body) 233 decoder.UseNumber() 234 var shape interface{} 235 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 236 var snapshot bytes.Buffer 237 io.Copy(&snapshot, ringBuffer) 238 err = &smithy.DeserializationError{ 239 Err: fmt.Errorf("failed to decode response body, %w", err), 240 Snapshot: snapshot.Bytes(), 241 } 242 return out, metadata, err 243 } 244 245 err = awsRestjson1_deserializeOpDocumentAddPermissionOutput(&output, shape) 246 if err != nil { 247 var snapshot bytes.Buffer 248 io.Copy(&snapshot, ringBuffer) 249 return out, metadata, &smithy.DeserializationError{ 250 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 251 Snapshot: snapshot.Bytes(), 252 } 253 } 254 255 return out, metadata, err 256} 257 258func awsRestjson1_deserializeOpErrorAddPermission(response *smithyhttp.Response, metadata *middleware.Metadata) error { 259 var errorBuffer bytes.Buffer 260 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 261 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 262 } 263 errorBody := bytes.NewReader(errorBuffer.Bytes()) 264 265 errorCode := "UnknownError" 266 errorMessage := errorCode 267 268 code := response.Header.Get("X-Amzn-ErrorType") 269 if len(code) != 0 { 270 errorCode = restjson.SanitizeErrorCode(code) 271 } 272 273 var buff [1024]byte 274 ringBuffer := smithyio.NewRingBuffer(buff[:]) 275 276 body := io.TeeReader(errorBody, ringBuffer) 277 decoder := json.NewDecoder(body) 278 decoder.UseNumber() 279 code, message, err := restjson.GetErrorInfo(decoder) 280 if err != nil { 281 var snapshot bytes.Buffer 282 io.Copy(&snapshot, ringBuffer) 283 err = &smithy.DeserializationError{ 284 Err: fmt.Errorf("failed to decode response body, %w", err), 285 Snapshot: snapshot.Bytes(), 286 } 287 return err 288 } 289 290 errorBody.Seek(0, io.SeekStart) 291 if len(code) != 0 { 292 errorCode = restjson.SanitizeErrorCode(code) 293 } 294 if len(message) != 0 { 295 errorMessage = message 296 } 297 298 switch { 299 case strings.EqualFold("InvalidParameterValueException", errorCode): 300 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 301 302 case strings.EqualFold("PolicyLengthExceededException", errorCode): 303 return awsRestjson1_deserializeErrorPolicyLengthExceededException(response, errorBody) 304 305 case strings.EqualFold("PreconditionFailedException", errorCode): 306 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 307 308 case strings.EqualFold("ResourceConflictException", errorCode): 309 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 310 311 case strings.EqualFold("ResourceNotFoundException", errorCode): 312 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 313 314 case strings.EqualFold("ServiceException", errorCode): 315 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 316 317 case strings.EqualFold("TooManyRequestsException", errorCode): 318 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 319 320 default: 321 genericError := &smithy.GenericAPIError{ 322 Code: errorCode, 323 Message: errorMessage, 324 } 325 return genericError 326 327 } 328} 329 330func awsRestjson1_deserializeOpDocumentAddPermissionOutput(v **AddPermissionOutput, value interface{}) error { 331 if v == nil { 332 return fmt.Errorf("unexpected nil of type %T", v) 333 } 334 if value == nil { 335 return nil 336 } 337 338 shape, ok := value.(map[string]interface{}) 339 if !ok { 340 return fmt.Errorf("unexpected JSON type %v", value) 341 } 342 343 var sv *AddPermissionOutput 344 if *v == nil { 345 sv = &AddPermissionOutput{} 346 } else { 347 sv = *v 348 } 349 350 for key, value := range shape { 351 switch key { 352 case "Statement": 353 if value != nil { 354 jtv, ok := value.(string) 355 if !ok { 356 return fmt.Errorf("expected String to be of type string, got %T instead", value) 357 } 358 sv.Statement = ptr.String(jtv) 359 } 360 361 default: 362 _, _ = key, value 363 364 } 365 } 366 *v = sv 367 return nil 368} 369 370type awsRestjson1_deserializeOpCreateAlias struct { 371} 372 373func (*awsRestjson1_deserializeOpCreateAlias) ID() string { 374 return "OperationDeserializer" 375} 376 377func (m *awsRestjson1_deserializeOpCreateAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 378 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 379) { 380 out, metadata, err = next.HandleDeserialize(ctx, in) 381 if err != nil { 382 return out, metadata, err 383 } 384 385 response, ok := out.RawResponse.(*smithyhttp.Response) 386 if !ok { 387 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 388 } 389 390 if response.StatusCode < 200 || response.StatusCode >= 300 { 391 return out, metadata, awsRestjson1_deserializeOpErrorCreateAlias(response, &metadata) 392 } 393 output := &CreateAliasOutput{} 394 out.Result = output 395 396 var buff [1024]byte 397 ringBuffer := smithyio.NewRingBuffer(buff[:]) 398 399 body := io.TeeReader(response.Body, ringBuffer) 400 401 decoder := json.NewDecoder(body) 402 decoder.UseNumber() 403 var shape interface{} 404 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 405 var snapshot bytes.Buffer 406 io.Copy(&snapshot, ringBuffer) 407 err = &smithy.DeserializationError{ 408 Err: fmt.Errorf("failed to decode response body, %w", err), 409 Snapshot: snapshot.Bytes(), 410 } 411 return out, metadata, err 412 } 413 414 err = awsRestjson1_deserializeOpDocumentCreateAliasOutput(&output, shape) 415 if err != nil { 416 var snapshot bytes.Buffer 417 io.Copy(&snapshot, ringBuffer) 418 return out, metadata, &smithy.DeserializationError{ 419 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 420 Snapshot: snapshot.Bytes(), 421 } 422 } 423 424 return out, metadata, err 425} 426 427func awsRestjson1_deserializeOpErrorCreateAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 428 var errorBuffer bytes.Buffer 429 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 430 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 431 } 432 errorBody := bytes.NewReader(errorBuffer.Bytes()) 433 434 errorCode := "UnknownError" 435 errorMessage := errorCode 436 437 code := response.Header.Get("X-Amzn-ErrorType") 438 if len(code) != 0 { 439 errorCode = restjson.SanitizeErrorCode(code) 440 } 441 442 var buff [1024]byte 443 ringBuffer := smithyio.NewRingBuffer(buff[:]) 444 445 body := io.TeeReader(errorBody, ringBuffer) 446 decoder := json.NewDecoder(body) 447 decoder.UseNumber() 448 code, message, err := restjson.GetErrorInfo(decoder) 449 if err != nil { 450 var snapshot bytes.Buffer 451 io.Copy(&snapshot, ringBuffer) 452 err = &smithy.DeserializationError{ 453 Err: fmt.Errorf("failed to decode response body, %w", err), 454 Snapshot: snapshot.Bytes(), 455 } 456 return err 457 } 458 459 errorBody.Seek(0, io.SeekStart) 460 if len(code) != 0 { 461 errorCode = restjson.SanitizeErrorCode(code) 462 } 463 if len(message) != 0 { 464 errorMessage = message 465 } 466 467 switch { 468 case strings.EqualFold("InvalidParameterValueException", errorCode): 469 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 470 471 case strings.EqualFold("ResourceConflictException", errorCode): 472 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 473 474 case strings.EqualFold("ResourceNotFoundException", errorCode): 475 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 476 477 case strings.EqualFold("ServiceException", errorCode): 478 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 479 480 case strings.EqualFold("TooManyRequestsException", errorCode): 481 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 482 483 default: 484 genericError := &smithy.GenericAPIError{ 485 Code: errorCode, 486 Message: errorMessage, 487 } 488 return genericError 489 490 } 491} 492 493func awsRestjson1_deserializeOpDocumentCreateAliasOutput(v **CreateAliasOutput, value interface{}) error { 494 if v == nil { 495 return fmt.Errorf("unexpected nil of type %T", v) 496 } 497 if value == nil { 498 return nil 499 } 500 501 shape, ok := value.(map[string]interface{}) 502 if !ok { 503 return fmt.Errorf("unexpected JSON type %v", value) 504 } 505 506 var sv *CreateAliasOutput 507 if *v == nil { 508 sv = &CreateAliasOutput{} 509 } else { 510 sv = *v 511 } 512 513 for key, value := range shape { 514 switch key { 515 case "AliasArn": 516 if value != nil { 517 jtv, ok := value.(string) 518 if !ok { 519 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 520 } 521 sv.AliasArn = ptr.String(jtv) 522 } 523 524 case "Description": 525 if value != nil { 526 jtv, ok := value.(string) 527 if !ok { 528 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 529 } 530 sv.Description = ptr.String(jtv) 531 } 532 533 case "FunctionVersion": 534 if value != nil { 535 jtv, ok := value.(string) 536 if !ok { 537 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 538 } 539 sv.FunctionVersion = ptr.String(jtv) 540 } 541 542 case "Name": 543 if value != nil { 544 jtv, ok := value.(string) 545 if !ok { 546 return fmt.Errorf("expected Alias to be of type string, got %T instead", value) 547 } 548 sv.Name = ptr.String(jtv) 549 } 550 551 case "RevisionId": 552 if value != nil { 553 jtv, ok := value.(string) 554 if !ok { 555 return fmt.Errorf("expected String to be of type string, got %T instead", value) 556 } 557 sv.RevisionId = ptr.String(jtv) 558 } 559 560 case "RoutingConfig": 561 if err := awsRestjson1_deserializeDocumentAliasRoutingConfiguration(&sv.RoutingConfig, value); err != nil { 562 return err 563 } 564 565 default: 566 _, _ = key, value 567 568 } 569 } 570 *v = sv 571 return nil 572} 573 574type awsRestjson1_deserializeOpCreateCodeSigningConfig struct { 575} 576 577func (*awsRestjson1_deserializeOpCreateCodeSigningConfig) ID() string { 578 return "OperationDeserializer" 579} 580 581func (m *awsRestjson1_deserializeOpCreateCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 582 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 583) { 584 out, metadata, err = next.HandleDeserialize(ctx, in) 585 if err != nil { 586 return out, metadata, err 587 } 588 589 response, ok := out.RawResponse.(*smithyhttp.Response) 590 if !ok { 591 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 592 } 593 594 if response.StatusCode < 200 || response.StatusCode >= 300 { 595 return out, metadata, awsRestjson1_deserializeOpErrorCreateCodeSigningConfig(response, &metadata) 596 } 597 output := &CreateCodeSigningConfigOutput{} 598 out.Result = output 599 600 var buff [1024]byte 601 ringBuffer := smithyio.NewRingBuffer(buff[:]) 602 603 body := io.TeeReader(response.Body, ringBuffer) 604 605 decoder := json.NewDecoder(body) 606 decoder.UseNumber() 607 var shape interface{} 608 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 609 var snapshot bytes.Buffer 610 io.Copy(&snapshot, ringBuffer) 611 err = &smithy.DeserializationError{ 612 Err: fmt.Errorf("failed to decode response body, %w", err), 613 Snapshot: snapshot.Bytes(), 614 } 615 return out, metadata, err 616 } 617 618 err = awsRestjson1_deserializeOpDocumentCreateCodeSigningConfigOutput(&output, shape) 619 if err != nil { 620 var snapshot bytes.Buffer 621 io.Copy(&snapshot, ringBuffer) 622 return out, metadata, &smithy.DeserializationError{ 623 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 624 Snapshot: snapshot.Bytes(), 625 } 626 } 627 628 return out, metadata, err 629} 630 631func awsRestjson1_deserializeOpErrorCreateCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 632 var errorBuffer bytes.Buffer 633 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 634 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 635 } 636 errorBody := bytes.NewReader(errorBuffer.Bytes()) 637 638 errorCode := "UnknownError" 639 errorMessage := errorCode 640 641 code := response.Header.Get("X-Amzn-ErrorType") 642 if len(code) != 0 { 643 errorCode = restjson.SanitizeErrorCode(code) 644 } 645 646 var buff [1024]byte 647 ringBuffer := smithyio.NewRingBuffer(buff[:]) 648 649 body := io.TeeReader(errorBody, ringBuffer) 650 decoder := json.NewDecoder(body) 651 decoder.UseNumber() 652 code, message, err := restjson.GetErrorInfo(decoder) 653 if err != nil { 654 var snapshot bytes.Buffer 655 io.Copy(&snapshot, ringBuffer) 656 err = &smithy.DeserializationError{ 657 Err: fmt.Errorf("failed to decode response body, %w", err), 658 Snapshot: snapshot.Bytes(), 659 } 660 return err 661 } 662 663 errorBody.Seek(0, io.SeekStart) 664 if len(code) != 0 { 665 errorCode = restjson.SanitizeErrorCode(code) 666 } 667 if len(message) != 0 { 668 errorMessage = message 669 } 670 671 switch { 672 case strings.EqualFold("InvalidParameterValueException", errorCode): 673 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 674 675 case strings.EqualFold("ServiceException", errorCode): 676 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 677 678 default: 679 genericError := &smithy.GenericAPIError{ 680 Code: errorCode, 681 Message: errorMessage, 682 } 683 return genericError 684 685 } 686} 687 688func awsRestjson1_deserializeOpDocumentCreateCodeSigningConfigOutput(v **CreateCodeSigningConfigOutput, value interface{}) error { 689 if v == nil { 690 return fmt.Errorf("unexpected nil of type %T", v) 691 } 692 if value == nil { 693 return nil 694 } 695 696 shape, ok := value.(map[string]interface{}) 697 if !ok { 698 return fmt.Errorf("unexpected JSON type %v", value) 699 } 700 701 var sv *CreateCodeSigningConfigOutput 702 if *v == nil { 703 sv = &CreateCodeSigningConfigOutput{} 704 } else { 705 sv = *v 706 } 707 708 for key, value := range shape { 709 switch key { 710 case "CodeSigningConfig": 711 if err := awsRestjson1_deserializeDocumentCodeSigningConfig(&sv.CodeSigningConfig, value); err != nil { 712 return err 713 } 714 715 default: 716 _, _ = key, value 717 718 } 719 } 720 *v = sv 721 return nil 722} 723 724type awsRestjson1_deserializeOpCreateEventSourceMapping struct { 725} 726 727func (*awsRestjson1_deserializeOpCreateEventSourceMapping) ID() string { 728 return "OperationDeserializer" 729} 730 731func (m *awsRestjson1_deserializeOpCreateEventSourceMapping) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 732 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 733) { 734 out, metadata, err = next.HandleDeserialize(ctx, in) 735 if err != nil { 736 return out, metadata, err 737 } 738 739 response, ok := out.RawResponse.(*smithyhttp.Response) 740 if !ok { 741 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 742 } 743 744 if response.StatusCode < 200 || response.StatusCode >= 300 { 745 return out, metadata, awsRestjson1_deserializeOpErrorCreateEventSourceMapping(response, &metadata) 746 } 747 output := &CreateEventSourceMappingOutput{} 748 out.Result = output 749 750 var buff [1024]byte 751 ringBuffer := smithyio.NewRingBuffer(buff[:]) 752 753 body := io.TeeReader(response.Body, ringBuffer) 754 755 decoder := json.NewDecoder(body) 756 decoder.UseNumber() 757 var shape interface{} 758 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 759 var snapshot bytes.Buffer 760 io.Copy(&snapshot, ringBuffer) 761 err = &smithy.DeserializationError{ 762 Err: fmt.Errorf("failed to decode response body, %w", err), 763 Snapshot: snapshot.Bytes(), 764 } 765 return out, metadata, err 766 } 767 768 err = awsRestjson1_deserializeOpDocumentCreateEventSourceMappingOutput(&output, shape) 769 if err != nil { 770 var snapshot bytes.Buffer 771 io.Copy(&snapshot, ringBuffer) 772 return out, metadata, &smithy.DeserializationError{ 773 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 774 Snapshot: snapshot.Bytes(), 775 } 776 } 777 778 return out, metadata, err 779} 780 781func awsRestjson1_deserializeOpErrorCreateEventSourceMapping(response *smithyhttp.Response, metadata *middleware.Metadata) error { 782 var errorBuffer bytes.Buffer 783 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 784 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 785 } 786 errorBody := bytes.NewReader(errorBuffer.Bytes()) 787 788 errorCode := "UnknownError" 789 errorMessage := errorCode 790 791 code := response.Header.Get("X-Amzn-ErrorType") 792 if len(code) != 0 { 793 errorCode = restjson.SanitizeErrorCode(code) 794 } 795 796 var buff [1024]byte 797 ringBuffer := smithyio.NewRingBuffer(buff[:]) 798 799 body := io.TeeReader(errorBody, ringBuffer) 800 decoder := json.NewDecoder(body) 801 decoder.UseNumber() 802 code, message, err := restjson.GetErrorInfo(decoder) 803 if err != nil { 804 var snapshot bytes.Buffer 805 io.Copy(&snapshot, ringBuffer) 806 err = &smithy.DeserializationError{ 807 Err: fmt.Errorf("failed to decode response body, %w", err), 808 Snapshot: snapshot.Bytes(), 809 } 810 return err 811 } 812 813 errorBody.Seek(0, io.SeekStart) 814 if len(code) != 0 { 815 errorCode = restjson.SanitizeErrorCode(code) 816 } 817 if len(message) != 0 { 818 errorMessage = message 819 } 820 821 switch { 822 case strings.EqualFold("InvalidParameterValueException", errorCode): 823 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 824 825 case strings.EqualFold("ResourceConflictException", errorCode): 826 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 827 828 case strings.EqualFold("ResourceNotFoundException", errorCode): 829 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 830 831 case strings.EqualFold("ServiceException", errorCode): 832 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 833 834 case strings.EqualFold("TooManyRequestsException", errorCode): 835 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 836 837 default: 838 genericError := &smithy.GenericAPIError{ 839 Code: errorCode, 840 Message: errorMessage, 841 } 842 return genericError 843 844 } 845} 846 847func awsRestjson1_deserializeOpDocumentCreateEventSourceMappingOutput(v **CreateEventSourceMappingOutput, value interface{}) error { 848 if v == nil { 849 return fmt.Errorf("unexpected nil of type %T", v) 850 } 851 if value == nil { 852 return nil 853 } 854 855 shape, ok := value.(map[string]interface{}) 856 if !ok { 857 return fmt.Errorf("unexpected JSON type %v", value) 858 } 859 860 var sv *CreateEventSourceMappingOutput 861 if *v == nil { 862 sv = &CreateEventSourceMappingOutput{} 863 } else { 864 sv = *v 865 } 866 867 for key, value := range shape { 868 switch key { 869 case "BatchSize": 870 if value != nil { 871 jtv, ok := value.(json.Number) 872 if !ok { 873 return fmt.Errorf("expected BatchSize to be json.Number, got %T instead", value) 874 } 875 i64, err := jtv.Int64() 876 if err != nil { 877 return err 878 } 879 sv.BatchSize = ptr.Int32(int32(i64)) 880 } 881 882 case "BisectBatchOnFunctionError": 883 if value != nil { 884 jtv, ok := value.(bool) 885 if !ok { 886 return fmt.Errorf("expected BisectBatchOnFunctionError to be of type *bool, got %T instead", value) 887 } 888 sv.BisectBatchOnFunctionError = ptr.Bool(jtv) 889 } 890 891 case "DestinationConfig": 892 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 893 return err 894 } 895 896 case "EventSourceArn": 897 if value != nil { 898 jtv, ok := value.(string) 899 if !ok { 900 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 901 } 902 sv.EventSourceArn = ptr.String(jtv) 903 } 904 905 case "FunctionArn": 906 if value != nil { 907 jtv, ok := value.(string) 908 if !ok { 909 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 910 } 911 sv.FunctionArn = ptr.String(jtv) 912 } 913 914 case "FunctionResponseTypes": 915 if err := awsRestjson1_deserializeDocumentFunctionResponseTypeList(&sv.FunctionResponseTypes, value); err != nil { 916 return err 917 } 918 919 case "LastModified": 920 if value != nil { 921 jtv, ok := value.(json.Number) 922 if !ok { 923 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 924 } 925 f64, err := jtv.Float64() 926 if err != nil { 927 return err 928 } 929 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 930 } 931 932 case "LastProcessingResult": 933 if value != nil { 934 jtv, ok := value.(string) 935 if !ok { 936 return fmt.Errorf("expected String to be of type string, got %T instead", value) 937 } 938 sv.LastProcessingResult = ptr.String(jtv) 939 } 940 941 case "MaximumBatchingWindowInSeconds": 942 if value != nil { 943 jtv, ok := value.(json.Number) 944 if !ok { 945 return fmt.Errorf("expected MaximumBatchingWindowInSeconds to be json.Number, got %T instead", value) 946 } 947 i64, err := jtv.Int64() 948 if err != nil { 949 return err 950 } 951 sv.MaximumBatchingWindowInSeconds = ptr.Int32(int32(i64)) 952 } 953 954 case "MaximumRecordAgeInSeconds": 955 if value != nil { 956 jtv, ok := value.(json.Number) 957 if !ok { 958 return fmt.Errorf("expected MaximumRecordAgeInSeconds to be json.Number, got %T instead", value) 959 } 960 i64, err := jtv.Int64() 961 if err != nil { 962 return err 963 } 964 sv.MaximumRecordAgeInSeconds = ptr.Int32(int32(i64)) 965 } 966 967 case "MaximumRetryAttempts": 968 if value != nil { 969 jtv, ok := value.(json.Number) 970 if !ok { 971 return fmt.Errorf("expected MaximumRetryAttemptsEventSourceMapping to be json.Number, got %T instead", value) 972 } 973 i64, err := jtv.Int64() 974 if err != nil { 975 return err 976 } 977 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 978 } 979 980 case "ParallelizationFactor": 981 if value != nil { 982 jtv, ok := value.(json.Number) 983 if !ok { 984 return fmt.Errorf("expected ParallelizationFactor to be json.Number, got %T instead", value) 985 } 986 i64, err := jtv.Int64() 987 if err != nil { 988 return err 989 } 990 sv.ParallelizationFactor = ptr.Int32(int32(i64)) 991 } 992 993 case "Queues": 994 if err := awsRestjson1_deserializeDocumentQueues(&sv.Queues, value); err != nil { 995 return err 996 } 997 998 case "SelfManagedEventSource": 999 if err := awsRestjson1_deserializeDocumentSelfManagedEventSource(&sv.SelfManagedEventSource, value); err != nil { 1000 return err 1001 } 1002 1003 case "SourceAccessConfigurations": 1004 if err := awsRestjson1_deserializeDocumentSourceAccessConfigurations(&sv.SourceAccessConfigurations, value); err != nil { 1005 return err 1006 } 1007 1008 case "StartingPosition": 1009 if value != nil { 1010 jtv, ok := value.(string) 1011 if !ok { 1012 return fmt.Errorf("expected EventSourcePosition to be of type string, got %T instead", value) 1013 } 1014 sv.StartingPosition = types.EventSourcePosition(jtv) 1015 } 1016 1017 case "StartingPositionTimestamp": 1018 if value != nil { 1019 jtv, ok := value.(json.Number) 1020 if !ok { 1021 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 1022 } 1023 f64, err := jtv.Float64() 1024 if err != nil { 1025 return err 1026 } 1027 sv.StartingPositionTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1028 } 1029 1030 case "State": 1031 if value != nil { 1032 jtv, ok := value.(string) 1033 if !ok { 1034 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1035 } 1036 sv.State = ptr.String(jtv) 1037 } 1038 1039 case "StateTransitionReason": 1040 if value != nil { 1041 jtv, ok := value.(string) 1042 if !ok { 1043 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1044 } 1045 sv.StateTransitionReason = ptr.String(jtv) 1046 } 1047 1048 case "Topics": 1049 if err := awsRestjson1_deserializeDocumentTopics(&sv.Topics, value); err != nil { 1050 return err 1051 } 1052 1053 case "TumblingWindowInSeconds": 1054 if value != nil { 1055 jtv, ok := value.(json.Number) 1056 if !ok { 1057 return fmt.Errorf("expected TumblingWindowInSeconds to be json.Number, got %T instead", value) 1058 } 1059 i64, err := jtv.Int64() 1060 if err != nil { 1061 return err 1062 } 1063 sv.TumblingWindowInSeconds = ptr.Int32(int32(i64)) 1064 } 1065 1066 case "UUID": 1067 if value != nil { 1068 jtv, ok := value.(string) 1069 if !ok { 1070 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1071 } 1072 sv.UUID = ptr.String(jtv) 1073 } 1074 1075 default: 1076 _, _ = key, value 1077 1078 } 1079 } 1080 *v = sv 1081 return nil 1082} 1083 1084type awsRestjson1_deserializeOpCreateFunction struct { 1085} 1086 1087func (*awsRestjson1_deserializeOpCreateFunction) ID() string { 1088 return "OperationDeserializer" 1089} 1090 1091func (m *awsRestjson1_deserializeOpCreateFunction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1092 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1093) { 1094 out, metadata, err = next.HandleDeserialize(ctx, in) 1095 if err != nil { 1096 return out, metadata, err 1097 } 1098 1099 response, ok := out.RawResponse.(*smithyhttp.Response) 1100 if !ok { 1101 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1102 } 1103 1104 if response.StatusCode < 200 || response.StatusCode >= 300 { 1105 return out, metadata, awsRestjson1_deserializeOpErrorCreateFunction(response, &metadata) 1106 } 1107 output := &CreateFunctionOutput{} 1108 out.Result = output 1109 1110 var buff [1024]byte 1111 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1112 1113 body := io.TeeReader(response.Body, ringBuffer) 1114 1115 decoder := json.NewDecoder(body) 1116 decoder.UseNumber() 1117 var shape interface{} 1118 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1119 var snapshot bytes.Buffer 1120 io.Copy(&snapshot, ringBuffer) 1121 err = &smithy.DeserializationError{ 1122 Err: fmt.Errorf("failed to decode response body, %w", err), 1123 Snapshot: snapshot.Bytes(), 1124 } 1125 return out, metadata, err 1126 } 1127 1128 err = awsRestjson1_deserializeOpDocumentCreateFunctionOutput(&output, shape) 1129 if err != nil { 1130 var snapshot bytes.Buffer 1131 io.Copy(&snapshot, ringBuffer) 1132 return out, metadata, &smithy.DeserializationError{ 1133 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1134 Snapshot: snapshot.Bytes(), 1135 } 1136 } 1137 1138 return out, metadata, err 1139} 1140 1141func awsRestjson1_deserializeOpErrorCreateFunction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1142 var errorBuffer bytes.Buffer 1143 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1144 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1145 } 1146 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1147 1148 errorCode := "UnknownError" 1149 errorMessage := errorCode 1150 1151 code := response.Header.Get("X-Amzn-ErrorType") 1152 if len(code) != 0 { 1153 errorCode = restjson.SanitizeErrorCode(code) 1154 } 1155 1156 var buff [1024]byte 1157 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1158 1159 body := io.TeeReader(errorBody, ringBuffer) 1160 decoder := json.NewDecoder(body) 1161 decoder.UseNumber() 1162 code, message, err := restjson.GetErrorInfo(decoder) 1163 if err != nil { 1164 var snapshot bytes.Buffer 1165 io.Copy(&snapshot, ringBuffer) 1166 err = &smithy.DeserializationError{ 1167 Err: fmt.Errorf("failed to decode response body, %w", err), 1168 Snapshot: snapshot.Bytes(), 1169 } 1170 return err 1171 } 1172 1173 errorBody.Seek(0, io.SeekStart) 1174 if len(code) != 0 { 1175 errorCode = restjson.SanitizeErrorCode(code) 1176 } 1177 if len(message) != 0 { 1178 errorMessage = message 1179 } 1180 1181 switch { 1182 case strings.EqualFold("CodeSigningConfigNotFoundException", errorCode): 1183 return awsRestjson1_deserializeErrorCodeSigningConfigNotFoundException(response, errorBody) 1184 1185 case strings.EqualFold("CodeStorageExceededException", errorCode): 1186 return awsRestjson1_deserializeErrorCodeStorageExceededException(response, errorBody) 1187 1188 case strings.EqualFold("CodeVerificationFailedException", errorCode): 1189 return awsRestjson1_deserializeErrorCodeVerificationFailedException(response, errorBody) 1190 1191 case strings.EqualFold("InvalidCodeSignatureException", errorCode): 1192 return awsRestjson1_deserializeErrorInvalidCodeSignatureException(response, errorBody) 1193 1194 case strings.EqualFold("InvalidParameterValueException", errorCode): 1195 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 1196 1197 case strings.EqualFold("ResourceConflictException", errorCode): 1198 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 1199 1200 case strings.EqualFold("ResourceNotFoundException", errorCode): 1201 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1202 1203 case strings.EqualFold("ServiceException", errorCode): 1204 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 1205 1206 case strings.EqualFold("TooManyRequestsException", errorCode): 1207 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1208 1209 default: 1210 genericError := &smithy.GenericAPIError{ 1211 Code: errorCode, 1212 Message: errorMessage, 1213 } 1214 return genericError 1215 1216 } 1217} 1218 1219func awsRestjson1_deserializeOpDocumentCreateFunctionOutput(v **CreateFunctionOutput, value interface{}) error { 1220 if v == nil { 1221 return fmt.Errorf("unexpected nil of type %T", v) 1222 } 1223 if value == nil { 1224 return nil 1225 } 1226 1227 shape, ok := value.(map[string]interface{}) 1228 if !ok { 1229 return fmt.Errorf("unexpected JSON type %v", value) 1230 } 1231 1232 var sv *CreateFunctionOutput 1233 if *v == nil { 1234 sv = &CreateFunctionOutput{} 1235 } else { 1236 sv = *v 1237 } 1238 1239 for key, value := range shape { 1240 switch key { 1241 case "CodeSha256": 1242 if value != nil { 1243 jtv, ok := value.(string) 1244 if !ok { 1245 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1246 } 1247 sv.CodeSha256 = ptr.String(jtv) 1248 } 1249 1250 case "CodeSize": 1251 if value != nil { 1252 jtv, ok := value.(json.Number) 1253 if !ok { 1254 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 1255 } 1256 i64, err := jtv.Int64() 1257 if err != nil { 1258 return err 1259 } 1260 sv.CodeSize = i64 1261 } 1262 1263 case "DeadLetterConfig": 1264 if err := awsRestjson1_deserializeDocumentDeadLetterConfig(&sv.DeadLetterConfig, value); err != nil { 1265 return err 1266 } 1267 1268 case "Description": 1269 if value != nil { 1270 jtv, ok := value.(string) 1271 if !ok { 1272 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 1273 } 1274 sv.Description = ptr.String(jtv) 1275 } 1276 1277 case "Environment": 1278 if err := awsRestjson1_deserializeDocumentEnvironmentResponse(&sv.Environment, value); err != nil { 1279 return err 1280 } 1281 1282 case "FileSystemConfigs": 1283 if err := awsRestjson1_deserializeDocumentFileSystemConfigList(&sv.FileSystemConfigs, value); err != nil { 1284 return err 1285 } 1286 1287 case "FunctionArn": 1288 if value != nil { 1289 jtv, ok := value.(string) 1290 if !ok { 1291 return fmt.Errorf("expected NameSpacedFunctionArn to be of type string, got %T instead", value) 1292 } 1293 sv.FunctionArn = ptr.String(jtv) 1294 } 1295 1296 case "FunctionName": 1297 if value != nil { 1298 jtv, ok := value.(string) 1299 if !ok { 1300 return fmt.Errorf("expected NamespacedFunctionName to be of type string, got %T instead", value) 1301 } 1302 sv.FunctionName = ptr.String(jtv) 1303 } 1304 1305 case "Handler": 1306 if value != nil { 1307 jtv, ok := value.(string) 1308 if !ok { 1309 return fmt.Errorf("expected Handler to be of type string, got %T instead", value) 1310 } 1311 sv.Handler = ptr.String(jtv) 1312 } 1313 1314 case "ImageConfigResponse": 1315 if err := awsRestjson1_deserializeDocumentImageConfigResponse(&sv.ImageConfigResponse, value); err != nil { 1316 return err 1317 } 1318 1319 case "KMSKeyArn": 1320 if value != nil { 1321 jtv, ok := value.(string) 1322 if !ok { 1323 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 1324 } 1325 sv.KMSKeyArn = ptr.String(jtv) 1326 } 1327 1328 case "LastModified": 1329 if value != nil { 1330 jtv, ok := value.(string) 1331 if !ok { 1332 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 1333 } 1334 sv.LastModified = ptr.String(jtv) 1335 } 1336 1337 case "LastUpdateStatus": 1338 if value != nil { 1339 jtv, ok := value.(string) 1340 if !ok { 1341 return fmt.Errorf("expected LastUpdateStatus to be of type string, got %T instead", value) 1342 } 1343 sv.LastUpdateStatus = types.LastUpdateStatus(jtv) 1344 } 1345 1346 case "LastUpdateStatusReason": 1347 if value != nil { 1348 jtv, ok := value.(string) 1349 if !ok { 1350 return fmt.Errorf("expected LastUpdateStatusReason to be of type string, got %T instead", value) 1351 } 1352 sv.LastUpdateStatusReason = ptr.String(jtv) 1353 } 1354 1355 case "LastUpdateStatusReasonCode": 1356 if value != nil { 1357 jtv, ok := value.(string) 1358 if !ok { 1359 return fmt.Errorf("expected LastUpdateStatusReasonCode to be of type string, got %T instead", value) 1360 } 1361 sv.LastUpdateStatusReasonCode = types.LastUpdateStatusReasonCode(jtv) 1362 } 1363 1364 case "Layers": 1365 if err := awsRestjson1_deserializeDocumentLayersReferenceList(&sv.Layers, value); err != nil { 1366 return err 1367 } 1368 1369 case "MasterArn": 1370 if value != nil { 1371 jtv, ok := value.(string) 1372 if !ok { 1373 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 1374 } 1375 sv.MasterArn = ptr.String(jtv) 1376 } 1377 1378 case "MemorySize": 1379 if value != nil { 1380 jtv, ok := value.(json.Number) 1381 if !ok { 1382 return fmt.Errorf("expected MemorySize to be json.Number, got %T instead", value) 1383 } 1384 i64, err := jtv.Int64() 1385 if err != nil { 1386 return err 1387 } 1388 sv.MemorySize = ptr.Int32(int32(i64)) 1389 } 1390 1391 case "PackageType": 1392 if value != nil { 1393 jtv, ok := value.(string) 1394 if !ok { 1395 return fmt.Errorf("expected PackageType to be of type string, got %T instead", value) 1396 } 1397 sv.PackageType = types.PackageType(jtv) 1398 } 1399 1400 case "RevisionId": 1401 if value != nil { 1402 jtv, ok := value.(string) 1403 if !ok { 1404 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1405 } 1406 sv.RevisionId = ptr.String(jtv) 1407 } 1408 1409 case "Role": 1410 if value != nil { 1411 jtv, ok := value.(string) 1412 if !ok { 1413 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 1414 } 1415 sv.Role = ptr.String(jtv) 1416 } 1417 1418 case "Runtime": 1419 if value != nil { 1420 jtv, ok := value.(string) 1421 if !ok { 1422 return fmt.Errorf("expected Runtime to be of type string, got %T instead", value) 1423 } 1424 sv.Runtime = types.Runtime(jtv) 1425 } 1426 1427 case "SigningJobArn": 1428 if value != nil { 1429 jtv, ok := value.(string) 1430 if !ok { 1431 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 1432 } 1433 sv.SigningJobArn = ptr.String(jtv) 1434 } 1435 1436 case "SigningProfileVersionArn": 1437 if value != nil { 1438 jtv, ok := value.(string) 1439 if !ok { 1440 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 1441 } 1442 sv.SigningProfileVersionArn = ptr.String(jtv) 1443 } 1444 1445 case "State": 1446 if value != nil { 1447 jtv, ok := value.(string) 1448 if !ok { 1449 return fmt.Errorf("expected State to be of type string, got %T instead", value) 1450 } 1451 sv.State = types.State(jtv) 1452 } 1453 1454 case "StateReason": 1455 if value != nil { 1456 jtv, ok := value.(string) 1457 if !ok { 1458 return fmt.Errorf("expected StateReason to be of type string, got %T instead", value) 1459 } 1460 sv.StateReason = ptr.String(jtv) 1461 } 1462 1463 case "StateReasonCode": 1464 if value != nil { 1465 jtv, ok := value.(string) 1466 if !ok { 1467 return fmt.Errorf("expected StateReasonCode to be of type string, got %T instead", value) 1468 } 1469 sv.StateReasonCode = types.StateReasonCode(jtv) 1470 } 1471 1472 case "Timeout": 1473 if value != nil { 1474 jtv, ok := value.(json.Number) 1475 if !ok { 1476 return fmt.Errorf("expected Timeout to be json.Number, got %T instead", value) 1477 } 1478 i64, err := jtv.Int64() 1479 if err != nil { 1480 return err 1481 } 1482 sv.Timeout = ptr.Int32(int32(i64)) 1483 } 1484 1485 case "TracingConfig": 1486 if err := awsRestjson1_deserializeDocumentTracingConfigResponse(&sv.TracingConfig, value); err != nil { 1487 return err 1488 } 1489 1490 case "Version": 1491 if value != nil { 1492 jtv, ok := value.(string) 1493 if !ok { 1494 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 1495 } 1496 sv.Version = ptr.String(jtv) 1497 } 1498 1499 case "VpcConfig": 1500 if err := awsRestjson1_deserializeDocumentVpcConfigResponse(&sv.VpcConfig, value); err != nil { 1501 return err 1502 } 1503 1504 default: 1505 _, _ = key, value 1506 1507 } 1508 } 1509 *v = sv 1510 return nil 1511} 1512 1513type awsRestjson1_deserializeOpDeleteAlias struct { 1514} 1515 1516func (*awsRestjson1_deserializeOpDeleteAlias) ID() string { 1517 return "OperationDeserializer" 1518} 1519 1520func (m *awsRestjson1_deserializeOpDeleteAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1521 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1522) { 1523 out, metadata, err = next.HandleDeserialize(ctx, in) 1524 if err != nil { 1525 return out, metadata, err 1526 } 1527 1528 response, ok := out.RawResponse.(*smithyhttp.Response) 1529 if !ok { 1530 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1531 } 1532 1533 if response.StatusCode < 200 || response.StatusCode >= 300 { 1534 return out, metadata, awsRestjson1_deserializeOpErrorDeleteAlias(response, &metadata) 1535 } 1536 output := &DeleteAliasOutput{} 1537 out.Result = output 1538 1539 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1540 return out, metadata, &smithy.DeserializationError{ 1541 Err: fmt.Errorf("failed to discard response body, %w", err), 1542 } 1543 } 1544 1545 return out, metadata, err 1546} 1547 1548func awsRestjson1_deserializeOpErrorDeleteAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1549 var errorBuffer bytes.Buffer 1550 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1551 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1552 } 1553 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1554 1555 errorCode := "UnknownError" 1556 errorMessage := errorCode 1557 1558 code := response.Header.Get("X-Amzn-ErrorType") 1559 if len(code) != 0 { 1560 errorCode = restjson.SanitizeErrorCode(code) 1561 } 1562 1563 var buff [1024]byte 1564 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1565 1566 body := io.TeeReader(errorBody, ringBuffer) 1567 decoder := json.NewDecoder(body) 1568 decoder.UseNumber() 1569 code, message, err := restjson.GetErrorInfo(decoder) 1570 if err != nil { 1571 var snapshot bytes.Buffer 1572 io.Copy(&snapshot, ringBuffer) 1573 err = &smithy.DeserializationError{ 1574 Err: fmt.Errorf("failed to decode response body, %w", err), 1575 Snapshot: snapshot.Bytes(), 1576 } 1577 return err 1578 } 1579 1580 errorBody.Seek(0, io.SeekStart) 1581 if len(code) != 0 { 1582 errorCode = restjson.SanitizeErrorCode(code) 1583 } 1584 if len(message) != 0 { 1585 errorMessage = message 1586 } 1587 1588 switch { 1589 case strings.EqualFold("InvalidParameterValueException", errorCode): 1590 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 1591 1592 case strings.EqualFold("ResourceConflictException", errorCode): 1593 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 1594 1595 case strings.EqualFold("ServiceException", errorCode): 1596 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 1597 1598 case strings.EqualFold("TooManyRequestsException", errorCode): 1599 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1600 1601 default: 1602 genericError := &smithy.GenericAPIError{ 1603 Code: errorCode, 1604 Message: errorMessage, 1605 } 1606 return genericError 1607 1608 } 1609} 1610 1611type awsRestjson1_deserializeOpDeleteCodeSigningConfig struct { 1612} 1613 1614func (*awsRestjson1_deserializeOpDeleteCodeSigningConfig) ID() string { 1615 return "OperationDeserializer" 1616} 1617 1618func (m *awsRestjson1_deserializeOpDeleteCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1619 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1620) { 1621 out, metadata, err = next.HandleDeserialize(ctx, in) 1622 if err != nil { 1623 return out, metadata, err 1624 } 1625 1626 response, ok := out.RawResponse.(*smithyhttp.Response) 1627 if !ok { 1628 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1629 } 1630 1631 if response.StatusCode < 200 || response.StatusCode >= 300 { 1632 return out, metadata, awsRestjson1_deserializeOpErrorDeleteCodeSigningConfig(response, &metadata) 1633 } 1634 output := &DeleteCodeSigningConfigOutput{} 1635 out.Result = output 1636 1637 return out, metadata, err 1638} 1639 1640func awsRestjson1_deserializeOpErrorDeleteCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1641 var errorBuffer bytes.Buffer 1642 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1643 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1644 } 1645 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1646 1647 errorCode := "UnknownError" 1648 errorMessage := errorCode 1649 1650 code := response.Header.Get("X-Amzn-ErrorType") 1651 if len(code) != 0 { 1652 errorCode = restjson.SanitizeErrorCode(code) 1653 } 1654 1655 var buff [1024]byte 1656 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1657 1658 body := io.TeeReader(errorBody, ringBuffer) 1659 decoder := json.NewDecoder(body) 1660 decoder.UseNumber() 1661 code, message, err := restjson.GetErrorInfo(decoder) 1662 if err != nil { 1663 var snapshot bytes.Buffer 1664 io.Copy(&snapshot, ringBuffer) 1665 err = &smithy.DeserializationError{ 1666 Err: fmt.Errorf("failed to decode response body, %w", err), 1667 Snapshot: snapshot.Bytes(), 1668 } 1669 return err 1670 } 1671 1672 errorBody.Seek(0, io.SeekStart) 1673 if len(code) != 0 { 1674 errorCode = restjson.SanitizeErrorCode(code) 1675 } 1676 if len(message) != 0 { 1677 errorMessage = message 1678 } 1679 1680 switch { 1681 case strings.EqualFold("InvalidParameterValueException", errorCode): 1682 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 1683 1684 case strings.EqualFold("ResourceConflictException", errorCode): 1685 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 1686 1687 case strings.EqualFold("ResourceNotFoundException", errorCode): 1688 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1689 1690 case strings.EqualFold("ServiceException", errorCode): 1691 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 1692 1693 default: 1694 genericError := &smithy.GenericAPIError{ 1695 Code: errorCode, 1696 Message: errorMessage, 1697 } 1698 return genericError 1699 1700 } 1701} 1702 1703type awsRestjson1_deserializeOpDeleteEventSourceMapping struct { 1704} 1705 1706func (*awsRestjson1_deserializeOpDeleteEventSourceMapping) ID() string { 1707 return "OperationDeserializer" 1708} 1709 1710func (m *awsRestjson1_deserializeOpDeleteEventSourceMapping) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1711 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1712) { 1713 out, metadata, err = next.HandleDeserialize(ctx, in) 1714 if err != nil { 1715 return out, metadata, err 1716 } 1717 1718 response, ok := out.RawResponse.(*smithyhttp.Response) 1719 if !ok { 1720 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1721 } 1722 1723 if response.StatusCode < 200 || response.StatusCode >= 300 { 1724 return out, metadata, awsRestjson1_deserializeOpErrorDeleteEventSourceMapping(response, &metadata) 1725 } 1726 output := &DeleteEventSourceMappingOutput{} 1727 out.Result = output 1728 1729 var buff [1024]byte 1730 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1731 1732 body := io.TeeReader(response.Body, ringBuffer) 1733 1734 decoder := json.NewDecoder(body) 1735 decoder.UseNumber() 1736 var shape interface{} 1737 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1738 var snapshot bytes.Buffer 1739 io.Copy(&snapshot, ringBuffer) 1740 err = &smithy.DeserializationError{ 1741 Err: fmt.Errorf("failed to decode response body, %w", err), 1742 Snapshot: snapshot.Bytes(), 1743 } 1744 return out, metadata, err 1745 } 1746 1747 err = awsRestjson1_deserializeOpDocumentDeleteEventSourceMappingOutput(&output, shape) 1748 if err != nil { 1749 var snapshot bytes.Buffer 1750 io.Copy(&snapshot, ringBuffer) 1751 return out, metadata, &smithy.DeserializationError{ 1752 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1753 Snapshot: snapshot.Bytes(), 1754 } 1755 } 1756 1757 return out, metadata, err 1758} 1759 1760func awsRestjson1_deserializeOpErrorDeleteEventSourceMapping(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1761 var errorBuffer bytes.Buffer 1762 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1763 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1764 } 1765 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1766 1767 errorCode := "UnknownError" 1768 errorMessage := errorCode 1769 1770 code := response.Header.Get("X-Amzn-ErrorType") 1771 if len(code) != 0 { 1772 errorCode = restjson.SanitizeErrorCode(code) 1773 } 1774 1775 var buff [1024]byte 1776 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1777 1778 body := io.TeeReader(errorBody, ringBuffer) 1779 decoder := json.NewDecoder(body) 1780 decoder.UseNumber() 1781 code, message, err := restjson.GetErrorInfo(decoder) 1782 if err != nil { 1783 var snapshot bytes.Buffer 1784 io.Copy(&snapshot, ringBuffer) 1785 err = &smithy.DeserializationError{ 1786 Err: fmt.Errorf("failed to decode response body, %w", err), 1787 Snapshot: snapshot.Bytes(), 1788 } 1789 return err 1790 } 1791 1792 errorBody.Seek(0, io.SeekStart) 1793 if len(code) != 0 { 1794 errorCode = restjson.SanitizeErrorCode(code) 1795 } 1796 if len(message) != 0 { 1797 errorMessage = message 1798 } 1799 1800 switch { 1801 case strings.EqualFold("InvalidParameterValueException", errorCode): 1802 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 1803 1804 case strings.EqualFold("ResourceInUseException", errorCode): 1805 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 1806 1807 case strings.EqualFold("ResourceNotFoundException", errorCode): 1808 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1809 1810 case strings.EqualFold("ServiceException", errorCode): 1811 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 1812 1813 case strings.EqualFold("TooManyRequestsException", errorCode): 1814 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1815 1816 default: 1817 genericError := &smithy.GenericAPIError{ 1818 Code: errorCode, 1819 Message: errorMessage, 1820 } 1821 return genericError 1822 1823 } 1824} 1825 1826func awsRestjson1_deserializeOpDocumentDeleteEventSourceMappingOutput(v **DeleteEventSourceMappingOutput, value interface{}) error { 1827 if v == nil { 1828 return fmt.Errorf("unexpected nil of type %T", v) 1829 } 1830 if value == nil { 1831 return nil 1832 } 1833 1834 shape, ok := value.(map[string]interface{}) 1835 if !ok { 1836 return fmt.Errorf("unexpected JSON type %v", value) 1837 } 1838 1839 var sv *DeleteEventSourceMappingOutput 1840 if *v == nil { 1841 sv = &DeleteEventSourceMappingOutput{} 1842 } else { 1843 sv = *v 1844 } 1845 1846 for key, value := range shape { 1847 switch key { 1848 case "BatchSize": 1849 if value != nil { 1850 jtv, ok := value.(json.Number) 1851 if !ok { 1852 return fmt.Errorf("expected BatchSize to be json.Number, got %T instead", value) 1853 } 1854 i64, err := jtv.Int64() 1855 if err != nil { 1856 return err 1857 } 1858 sv.BatchSize = ptr.Int32(int32(i64)) 1859 } 1860 1861 case "BisectBatchOnFunctionError": 1862 if value != nil { 1863 jtv, ok := value.(bool) 1864 if !ok { 1865 return fmt.Errorf("expected BisectBatchOnFunctionError to be of type *bool, got %T instead", value) 1866 } 1867 sv.BisectBatchOnFunctionError = ptr.Bool(jtv) 1868 } 1869 1870 case "DestinationConfig": 1871 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 1872 return err 1873 } 1874 1875 case "EventSourceArn": 1876 if value != nil { 1877 jtv, ok := value.(string) 1878 if !ok { 1879 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 1880 } 1881 sv.EventSourceArn = ptr.String(jtv) 1882 } 1883 1884 case "FunctionArn": 1885 if value != nil { 1886 jtv, ok := value.(string) 1887 if !ok { 1888 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 1889 } 1890 sv.FunctionArn = ptr.String(jtv) 1891 } 1892 1893 case "FunctionResponseTypes": 1894 if err := awsRestjson1_deserializeDocumentFunctionResponseTypeList(&sv.FunctionResponseTypes, value); err != nil { 1895 return err 1896 } 1897 1898 case "LastModified": 1899 if value != nil { 1900 jtv, ok := value.(json.Number) 1901 if !ok { 1902 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 1903 } 1904 f64, err := jtv.Float64() 1905 if err != nil { 1906 return err 1907 } 1908 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1909 } 1910 1911 case "LastProcessingResult": 1912 if value != nil { 1913 jtv, ok := value.(string) 1914 if !ok { 1915 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1916 } 1917 sv.LastProcessingResult = ptr.String(jtv) 1918 } 1919 1920 case "MaximumBatchingWindowInSeconds": 1921 if value != nil { 1922 jtv, ok := value.(json.Number) 1923 if !ok { 1924 return fmt.Errorf("expected MaximumBatchingWindowInSeconds to be json.Number, got %T instead", value) 1925 } 1926 i64, err := jtv.Int64() 1927 if err != nil { 1928 return err 1929 } 1930 sv.MaximumBatchingWindowInSeconds = ptr.Int32(int32(i64)) 1931 } 1932 1933 case "MaximumRecordAgeInSeconds": 1934 if value != nil { 1935 jtv, ok := value.(json.Number) 1936 if !ok { 1937 return fmt.Errorf("expected MaximumRecordAgeInSeconds to be json.Number, got %T instead", value) 1938 } 1939 i64, err := jtv.Int64() 1940 if err != nil { 1941 return err 1942 } 1943 sv.MaximumRecordAgeInSeconds = ptr.Int32(int32(i64)) 1944 } 1945 1946 case "MaximumRetryAttempts": 1947 if value != nil { 1948 jtv, ok := value.(json.Number) 1949 if !ok { 1950 return fmt.Errorf("expected MaximumRetryAttemptsEventSourceMapping to be json.Number, got %T instead", value) 1951 } 1952 i64, err := jtv.Int64() 1953 if err != nil { 1954 return err 1955 } 1956 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 1957 } 1958 1959 case "ParallelizationFactor": 1960 if value != nil { 1961 jtv, ok := value.(json.Number) 1962 if !ok { 1963 return fmt.Errorf("expected ParallelizationFactor to be json.Number, got %T instead", value) 1964 } 1965 i64, err := jtv.Int64() 1966 if err != nil { 1967 return err 1968 } 1969 sv.ParallelizationFactor = ptr.Int32(int32(i64)) 1970 } 1971 1972 case "Queues": 1973 if err := awsRestjson1_deserializeDocumentQueues(&sv.Queues, value); err != nil { 1974 return err 1975 } 1976 1977 case "SelfManagedEventSource": 1978 if err := awsRestjson1_deserializeDocumentSelfManagedEventSource(&sv.SelfManagedEventSource, value); err != nil { 1979 return err 1980 } 1981 1982 case "SourceAccessConfigurations": 1983 if err := awsRestjson1_deserializeDocumentSourceAccessConfigurations(&sv.SourceAccessConfigurations, value); err != nil { 1984 return err 1985 } 1986 1987 case "StartingPosition": 1988 if value != nil { 1989 jtv, ok := value.(string) 1990 if !ok { 1991 return fmt.Errorf("expected EventSourcePosition to be of type string, got %T instead", value) 1992 } 1993 sv.StartingPosition = types.EventSourcePosition(jtv) 1994 } 1995 1996 case "StartingPositionTimestamp": 1997 if value != nil { 1998 jtv, ok := value.(json.Number) 1999 if !ok { 2000 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 2001 } 2002 f64, err := jtv.Float64() 2003 if err != nil { 2004 return err 2005 } 2006 sv.StartingPositionTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2007 } 2008 2009 case "State": 2010 if value != nil { 2011 jtv, ok := value.(string) 2012 if !ok { 2013 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2014 } 2015 sv.State = ptr.String(jtv) 2016 } 2017 2018 case "StateTransitionReason": 2019 if value != nil { 2020 jtv, ok := value.(string) 2021 if !ok { 2022 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2023 } 2024 sv.StateTransitionReason = ptr.String(jtv) 2025 } 2026 2027 case "Topics": 2028 if err := awsRestjson1_deserializeDocumentTopics(&sv.Topics, value); err != nil { 2029 return err 2030 } 2031 2032 case "TumblingWindowInSeconds": 2033 if value != nil { 2034 jtv, ok := value.(json.Number) 2035 if !ok { 2036 return fmt.Errorf("expected TumblingWindowInSeconds to be json.Number, got %T instead", value) 2037 } 2038 i64, err := jtv.Int64() 2039 if err != nil { 2040 return err 2041 } 2042 sv.TumblingWindowInSeconds = ptr.Int32(int32(i64)) 2043 } 2044 2045 case "UUID": 2046 if value != nil { 2047 jtv, ok := value.(string) 2048 if !ok { 2049 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2050 } 2051 sv.UUID = ptr.String(jtv) 2052 } 2053 2054 default: 2055 _, _ = key, value 2056 2057 } 2058 } 2059 *v = sv 2060 return nil 2061} 2062 2063type awsRestjson1_deserializeOpDeleteFunction struct { 2064} 2065 2066func (*awsRestjson1_deserializeOpDeleteFunction) ID() string { 2067 return "OperationDeserializer" 2068} 2069 2070func (m *awsRestjson1_deserializeOpDeleteFunction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2071 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2072) { 2073 out, metadata, err = next.HandleDeserialize(ctx, in) 2074 if err != nil { 2075 return out, metadata, err 2076 } 2077 2078 response, ok := out.RawResponse.(*smithyhttp.Response) 2079 if !ok { 2080 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2081 } 2082 2083 if response.StatusCode < 200 || response.StatusCode >= 300 { 2084 return out, metadata, awsRestjson1_deserializeOpErrorDeleteFunction(response, &metadata) 2085 } 2086 output := &DeleteFunctionOutput{} 2087 out.Result = output 2088 2089 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2090 return out, metadata, &smithy.DeserializationError{ 2091 Err: fmt.Errorf("failed to discard response body, %w", err), 2092 } 2093 } 2094 2095 return out, metadata, err 2096} 2097 2098func awsRestjson1_deserializeOpErrorDeleteFunction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2099 var errorBuffer bytes.Buffer 2100 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2101 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2102 } 2103 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2104 2105 errorCode := "UnknownError" 2106 errorMessage := errorCode 2107 2108 code := response.Header.Get("X-Amzn-ErrorType") 2109 if len(code) != 0 { 2110 errorCode = restjson.SanitizeErrorCode(code) 2111 } 2112 2113 var buff [1024]byte 2114 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2115 2116 body := io.TeeReader(errorBody, ringBuffer) 2117 decoder := json.NewDecoder(body) 2118 decoder.UseNumber() 2119 code, message, err := restjson.GetErrorInfo(decoder) 2120 if err != nil { 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 err 2128 } 2129 2130 errorBody.Seek(0, io.SeekStart) 2131 if len(code) != 0 { 2132 errorCode = restjson.SanitizeErrorCode(code) 2133 } 2134 if len(message) != 0 { 2135 errorMessage = message 2136 } 2137 2138 switch { 2139 case strings.EqualFold("InvalidParameterValueException", errorCode): 2140 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 2141 2142 case strings.EqualFold("ResourceConflictException", errorCode): 2143 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 2144 2145 case strings.EqualFold("ResourceNotFoundException", errorCode): 2146 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2147 2148 case strings.EqualFold("ServiceException", errorCode): 2149 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2150 2151 case strings.EqualFold("TooManyRequestsException", errorCode): 2152 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2153 2154 default: 2155 genericError := &smithy.GenericAPIError{ 2156 Code: errorCode, 2157 Message: errorMessage, 2158 } 2159 return genericError 2160 2161 } 2162} 2163 2164type awsRestjson1_deserializeOpDeleteFunctionCodeSigningConfig struct { 2165} 2166 2167func (*awsRestjson1_deserializeOpDeleteFunctionCodeSigningConfig) ID() string { 2168 return "OperationDeserializer" 2169} 2170 2171func (m *awsRestjson1_deserializeOpDeleteFunctionCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2172 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2173) { 2174 out, metadata, err = next.HandleDeserialize(ctx, in) 2175 if err != nil { 2176 return out, metadata, err 2177 } 2178 2179 response, ok := out.RawResponse.(*smithyhttp.Response) 2180 if !ok { 2181 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2182 } 2183 2184 if response.StatusCode < 200 || response.StatusCode >= 300 { 2185 return out, metadata, awsRestjson1_deserializeOpErrorDeleteFunctionCodeSigningConfig(response, &metadata) 2186 } 2187 output := &DeleteFunctionCodeSigningConfigOutput{} 2188 out.Result = output 2189 2190 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2191 return out, metadata, &smithy.DeserializationError{ 2192 Err: fmt.Errorf("failed to discard response body, %w", err), 2193 } 2194 } 2195 2196 return out, metadata, err 2197} 2198 2199func awsRestjson1_deserializeOpErrorDeleteFunctionCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2200 var errorBuffer bytes.Buffer 2201 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2202 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2203 } 2204 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2205 2206 errorCode := "UnknownError" 2207 errorMessage := errorCode 2208 2209 code := response.Header.Get("X-Amzn-ErrorType") 2210 if len(code) != 0 { 2211 errorCode = restjson.SanitizeErrorCode(code) 2212 } 2213 2214 var buff [1024]byte 2215 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2216 2217 body := io.TeeReader(errorBody, ringBuffer) 2218 decoder := json.NewDecoder(body) 2219 decoder.UseNumber() 2220 code, message, err := restjson.GetErrorInfo(decoder) 2221 if err != nil { 2222 var snapshot bytes.Buffer 2223 io.Copy(&snapshot, ringBuffer) 2224 err = &smithy.DeserializationError{ 2225 Err: fmt.Errorf("failed to decode response body, %w", err), 2226 Snapshot: snapshot.Bytes(), 2227 } 2228 return err 2229 } 2230 2231 errorBody.Seek(0, io.SeekStart) 2232 if len(code) != 0 { 2233 errorCode = restjson.SanitizeErrorCode(code) 2234 } 2235 if len(message) != 0 { 2236 errorMessage = message 2237 } 2238 2239 switch { 2240 case strings.EqualFold("CodeSigningConfigNotFoundException", errorCode): 2241 return awsRestjson1_deserializeErrorCodeSigningConfigNotFoundException(response, errorBody) 2242 2243 case strings.EqualFold("InvalidParameterValueException", errorCode): 2244 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 2245 2246 case strings.EqualFold("ResourceConflictException", errorCode): 2247 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 2248 2249 case strings.EqualFold("ResourceNotFoundException", errorCode): 2250 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2251 2252 case strings.EqualFold("ServiceException", errorCode): 2253 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2254 2255 case strings.EqualFold("TooManyRequestsException", errorCode): 2256 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2257 2258 default: 2259 genericError := &smithy.GenericAPIError{ 2260 Code: errorCode, 2261 Message: errorMessage, 2262 } 2263 return genericError 2264 2265 } 2266} 2267 2268type awsRestjson1_deserializeOpDeleteFunctionConcurrency struct { 2269} 2270 2271func (*awsRestjson1_deserializeOpDeleteFunctionConcurrency) ID() string { 2272 return "OperationDeserializer" 2273} 2274 2275func (m *awsRestjson1_deserializeOpDeleteFunctionConcurrency) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2276 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2277) { 2278 out, metadata, err = next.HandleDeserialize(ctx, in) 2279 if err != nil { 2280 return out, metadata, err 2281 } 2282 2283 response, ok := out.RawResponse.(*smithyhttp.Response) 2284 if !ok { 2285 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2286 } 2287 2288 if response.StatusCode < 200 || response.StatusCode >= 300 { 2289 return out, metadata, awsRestjson1_deserializeOpErrorDeleteFunctionConcurrency(response, &metadata) 2290 } 2291 output := &DeleteFunctionConcurrencyOutput{} 2292 out.Result = output 2293 2294 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2295 return out, metadata, &smithy.DeserializationError{ 2296 Err: fmt.Errorf("failed to discard response body, %w", err), 2297 } 2298 } 2299 2300 return out, metadata, err 2301} 2302 2303func awsRestjson1_deserializeOpErrorDeleteFunctionConcurrency(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2304 var errorBuffer bytes.Buffer 2305 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2306 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2307 } 2308 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2309 2310 errorCode := "UnknownError" 2311 errorMessage := errorCode 2312 2313 code := response.Header.Get("X-Amzn-ErrorType") 2314 if len(code) != 0 { 2315 errorCode = restjson.SanitizeErrorCode(code) 2316 } 2317 2318 var buff [1024]byte 2319 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2320 2321 body := io.TeeReader(errorBody, ringBuffer) 2322 decoder := json.NewDecoder(body) 2323 decoder.UseNumber() 2324 code, message, err := restjson.GetErrorInfo(decoder) 2325 if err != nil { 2326 var snapshot bytes.Buffer 2327 io.Copy(&snapshot, ringBuffer) 2328 err = &smithy.DeserializationError{ 2329 Err: fmt.Errorf("failed to decode response body, %w", err), 2330 Snapshot: snapshot.Bytes(), 2331 } 2332 return err 2333 } 2334 2335 errorBody.Seek(0, io.SeekStart) 2336 if len(code) != 0 { 2337 errorCode = restjson.SanitizeErrorCode(code) 2338 } 2339 if len(message) != 0 { 2340 errorMessage = message 2341 } 2342 2343 switch { 2344 case strings.EqualFold("InvalidParameterValueException", errorCode): 2345 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 2346 2347 case strings.EqualFold("ResourceConflictException", errorCode): 2348 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 2349 2350 case strings.EqualFold("ResourceNotFoundException", errorCode): 2351 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2352 2353 case strings.EqualFold("ServiceException", errorCode): 2354 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2355 2356 case strings.EqualFold("TooManyRequestsException", errorCode): 2357 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2358 2359 default: 2360 genericError := &smithy.GenericAPIError{ 2361 Code: errorCode, 2362 Message: errorMessage, 2363 } 2364 return genericError 2365 2366 } 2367} 2368 2369type awsRestjson1_deserializeOpDeleteFunctionEventInvokeConfig struct { 2370} 2371 2372func (*awsRestjson1_deserializeOpDeleteFunctionEventInvokeConfig) ID() string { 2373 return "OperationDeserializer" 2374} 2375 2376func (m *awsRestjson1_deserializeOpDeleteFunctionEventInvokeConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2377 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2378) { 2379 out, metadata, err = next.HandleDeserialize(ctx, in) 2380 if err != nil { 2381 return out, metadata, err 2382 } 2383 2384 response, ok := out.RawResponse.(*smithyhttp.Response) 2385 if !ok { 2386 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2387 } 2388 2389 if response.StatusCode < 200 || response.StatusCode >= 300 { 2390 return out, metadata, awsRestjson1_deserializeOpErrorDeleteFunctionEventInvokeConfig(response, &metadata) 2391 } 2392 output := &DeleteFunctionEventInvokeConfigOutput{} 2393 out.Result = output 2394 2395 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2396 return out, metadata, &smithy.DeserializationError{ 2397 Err: fmt.Errorf("failed to discard response body, %w", err), 2398 } 2399 } 2400 2401 return out, metadata, err 2402} 2403 2404func awsRestjson1_deserializeOpErrorDeleteFunctionEventInvokeConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2405 var errorBuffer bytes.Buffer 2406 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2407 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2408 } 2409 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2410 2411 errorCode := "UnknownError" 2412 errorMessage := errorCode 2413 2414 code := response.Header.Get("X-Amzn-ErrorType") 2415 if len(code) != 0 { 2416 errorCode = restjson.SanitizeErrorCode(code) 2417 } 2418 2419 var buff [1024]byte 2420 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2421 2422 body := io.TeeReader(errorBody, ringBuffer) 2423 decoder := json.NewDecoder(body) 2424 decoder.UseNumber() 2425 code, message, err := restjson.GetErrorInfo(decoder) 2426 if err != nil { 2427 var snapshot bytes.Buffer 2428 io.Copy(&snapshot, ringBuffer) 2429 err = &smithy.DeserializationError{ 2430 Err: fmt.Errorf("failed to decode response body, %w", err), 2431 Snapshot: snapshot.Bytes(), 2432 } 2433 return err 2434 } 2435 2436 errorBody.Seek(0, io.SeekStart) 2437 if len(code) != 0 { 2438 errorCode = restjson.SanitizeErrorCode(code) 2439 } 2440 if len(message) != 0 { 2441 errorMessage = message 2442 } 2443 2444 switch { 2445 case strings.EqualFold("InvalidParameterValueException", errorCode): 2446 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 2447 2448 case strings.EqualFold("ResourceNotFoundException", errorCode): 2449 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2450 2451 case strings.EqualFold("ServiceException", errorCode): 2452 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2453 2454 case strings.EqualFold("TooManyRequestsException", errorCode): 2455 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2456 2457 default: 2458 genericError := &smithy.GenericAPIError{ 2459 Code: errorCode, 2460 Message: errorMessage, 2461 } 2462 return genericError 2463 2464 } 2465} 2466 2467type awsRestjson1_deserializeOpDeleteLayerVersion struct { 2468} 2469 2470func (*awsRestjson1_deserializeOpDeleteLayerVersion) ID() string { 2471 return "OperationDeserializer" 2472} 2473 2474func (m *awsRestjson1_deserializeOpDeleteLayerVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2475 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2476) { 2477 out, metadata, err = next.HandleDeserialize(ctx, in) 2478 if err != nil { 2479 return out, metadata, err 2480 } 2481 2482 response, ok := out.RawResponse.(*smithyhttp.Response) 2483 if !ok { 2484 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2485 } 2486 2487 if response.StatusCode < 200 || response.StatusCode >= 300 { 2488 return out, metadata, awsRestjson1_deserializeOpErrorDeleteLayerVersion(response, &metadata) 2489 } 2490 output := &DeleteLayerVersionOutput{} 2491 out.Result = output 2492 2493 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2494 return out, metadata, &smithy.DeserializationError{ 2495 Err: fmt.Errorf("failed to discard response body, %w", err), 2496 } 2497 } 2498 2499 return out, metadata, err 2500} 2501 2502func awsRestjson1_deserializeOpErrorDeleteLayerVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2503 var errorBuffer bytes.Buffer 2504 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2505 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2506 } 2507 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2508 2509 errorCode := "UnknownError" 2510 errorMessage := errorCode 2511 2512 code := response.Header.Get("X-Amzn-ErrorType") 2513 if len(code) != 0 { 2514 errorCode = restjson.SanitizeErrorCode(code) 2515 } 2516 2517 var buff [1024]byte 2518 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2519 2520 body := io.TeeReader(errorBody, ringBuffer) 2521 decoder := json.NewDecoder(body) 2522 decoder.UseNumber() 2523 code, message, err := restjson.GetErrorInfo(decoder) 2524 if err != nil { 2525 var snapshot bytes.Buffer 2526 io.Copy(&snapshot, ringBuffer) 2527 err = &smithy.DeserializationError{ 2528 Err: fmt.Errorf("failed to decode response body, %w", err), 2529 Snapshot: snapshot.Bytes(), 2530 } 2531 return err 2532 } 2533 2534 errorBody.Seek(0, io.SeekStart) 2535 if len(code) != 0 { 2536 errorCode = restjson.SanitizeErrorCode(code) 2537 } 2538 if len(message) != 0 { 2539 errorMessage = message 2540 } 2541 2542 switch { 2543 case strings.EqualFold("ServiceException", errorCode): 2544 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2545 2546 case strings.EqualFold("TooManyRequestsException", errorCode): 2547 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2548 2549 default: 2550 genericError := &smithy.GenericAPIError{ 2551 Code: errorCode, 2552 Message: errorMessage, 2553 } 2554 return genericError 2555 2556 } 2557} 2558 2559type awsRestjson1_deserializeOpDeleteProvisionedConcurrencyConfig struct { 2560} 2561 2562func (*awsRestjson1_deserializeOpDeleteProvisionedConcurrencyConfig) ID() string { 2563 return "OperationDeserializer" 2564} 2565 2566func (m *awsRestjson1_deserializeOpDeleteProvisionedConcurrencyConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2567 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2568) { 2569 out, metadata, err = next.HandleDeserialize(ctx, in) 2570 if err != nil { 2571 return out, metadata, err 2572 } 2573 2574 response, ok := out.RawResponse.(*smithyhttp.Response) 2575 if !ok { 2576 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2577 } 2578 2579 if response.StatusCode < 200 || response.StatusCode >= 300 { 2580 return out, metadata, awsRestjson1_deserializeOpErrorDeleteProvisionedConcurrencyConfig(response, &metadata) 2581 } 2582 output := &DeleteProvisionedConcurrencyConfigOutput{} 2583 out.Result = output 2584 2585 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2586 return out, metadata, &smithy.DeserializationError{ 2587 Err: fmt.Errorf("failed to discard response body, %w", err), 2588 } 2589 } 2590 2591 return out, metadata, err 2592} 2593 2594func awsRestjson1_deserializeOpErrorDeleteProvisionedConcurrencyConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2595 var errorBuffer bytes.Buffer 2596 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2597 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2598 } 2599 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2600 2601 errorCode := "UnknownError" 2602 errorMessage := errorCode 2603 2604 code := response.Header.Get("X-Amzn-ErrorType") 2605 if len(code) != 0 { 2606 errorCode = restjson.SanitizeErrorCode(code) 2607 } 2608 2609 var buff [1024]byte 2610 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2611 2612 body := io.TeeReader(errorBody, ringBuffer) 2613 decoder := json.NewDecoder(body) 2614 decoder.UseNumber() 2615 code, message, err := restjson.GetErrorInfo(decoder) 2616 if err != nil { 2617 var snapshot bytes.Buffer 2618 io.Copy(&snapshot, ringBuffer) 2619 err = &smithy.DeserializationError{ 2620 Err: fmt.Errorf("failed to decode response body, %w", err), 2621 Snapshot: snapshot.Bytes(), 2622 } 2623 return err 2624 } 2625 2626 errorBody.Seek(0, io.SeekStart) 2627 if len(code) != 0 { 2628 errorCode = restjson.SanitizeErrorCode(code) 2629 } 2630 if len(message) != 0 { 2631 errorMessage = message 2632 } 2633 2634 switch { 2635 case strings.EqualFold("InvalidParameterValueException", errorCode): 2636 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 2637 2638 case strings.EqualFold("ResourceConflictException", errorCode): 2639 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 2640 2641 case strings.EqualFold("ResourceNotFoundException", errorCode): 2642 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2643 2644 case strings.EqualFold("ServiceException", errorCode): 2645 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2646 2647 case strings.EqualFold("TooManyRequestsException", errorCode): 2648 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2649 2650 default: 2651 genericError := &smithy.GenericAPIError{ 2652 Code: errorCode, 2653 Message: errorMessage, 2654 } 2655 return genericError 2656 2657 } 2658} 2659 2660type awsRestjson1_deserializeOpGetAccountSettings struct { 2661} 2662 2663func (*awsRestjson1_deserializeOpGetAccountSettings) ID() string { 2664 return "OperationDeserializer" 2665} 2666 2667func (m *awsRestjson1_deserializeOpGetAccountSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2668 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2669) { 2670 out, metadata, err = next.HandleDeserialize(ctx, in) 2671 if err != nil { 2672 return out, metadata, err 2673 } 2674 2675 response, ok := out.RawResponse.(*smithyhttp.Response) 2676 if !ok { 2677 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2678 } 2679 2680 if response.StatusCode < 200 || response.StatusCode >= 300 { 2681 return out, metadata, awsRestjson1_deserializeOpErrorGetAccountSettings(response, &metadata) 2682 } 2683 output := &GetAccountSettingsOutput{} 2684 out.Result = output 2685 2686 var buff [1024]byte 2687 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2688 2689 body := io.TeeReader(response.Body, ringBuffer) 2690 2691 decoder := json.NewDecoder(body) 2692 decoder.UseNumber() 2693 var shape interface{} 2694 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2695 var snapshot bytes.Buffer 2696 io.Copy(&snapshot, ringBuffer) 2697 err = &smithy.DeserializationError{ 2698 Err: fmt.Errorf("failed to decode response body, %w", err), 2699 Snapshot: snapshot.Bytes(), 2700 } 2701 return out, metadata, err 2702 } 2703 2704 err = awsRestjson1_deserializeOpDocumentGetAccountSettingsOutput(&output, shape) 2705 if err != nil { 2706 var snapshot bytes.Buffer 2707 io.Copy(&snapshot, ringBuffer) 2708 return out, metadata, &smithy.DeserializationError{ 2709 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2710 Snapshot: snapshot.Bytes(), 2711 } 2712 } 2713 2714 return out, metadata, err 2715} 2716 2717func awsRestjson1_deserializeOpErrorGetAccountSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2718 var errorBuffer bytes.Buffer 2719 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2720 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2721 } 2722 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2723 2724 errorCode := "UnknownError" 2725 errorMessage := errorCode 2726 2727 code := response.Header.Get("X-Amzn-ErrorType") 2728 if len(code) != 0 { 2729 errorCode = restjson.SanitizeErrorCode(code) 2730 } 2731 2732 var buff [1024]byte 2733 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2734 2735 body := io.TeeReader(errorBody, ringBuffer) 2736 decoder := json.NewDecoder(body) 2737 decoder.UseNumber() 2738 code, message, err := restjson.GetErrorInfo(decoder) 2739 if err != nil { 2740 var snapshot bytes.Buffer 2741 io.Copy(&snapshot, ringBuffer) 2742 err = &smithy.DeserializationError{ 2743 Err: fmt.Errorf("failed to decode response body, %w", err), 2744 Snapshot: snapshot.Bytes(), 2745 } 2746 return err 2747 } 2748 2749 errorBody.Seek(0, io.SeekStart) 2750 if len(code) != 0 { 2751 errorCode = restjson.SanitizeErrorCode(code) 2752 } 2753 if len(message) != 0 { 2754 errorMessage = message 2755 } 2756 2757 switch { 2758 case strings.EqualFold("ServiceException", errorCode): 2759 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2760 2761 case strings.EqualFold("TooManyRequestsException", errorCode): 2762 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2763 2764 default: 2765 genericError := &smithy.GenericAPIError{ 2766 Code: errorCode, 2767 Message: errorMessage, 2768 } 2769 return genericError 2770 2771 } 2772} 2773 2774func awsRestjson1_deserializeOpDocumentGetAccountSettingsOutput(v **GetAccountSettingsOutput, value interface{}) error { 2775 if v == nil { 2776 return fmt.Errorf("unexpected nil of type %T", v) 2777 } 2778 if value == nil { 2779 return nil 2780 } 2781 2782 shape, ok := value.(map[string]interface{}) 2783 if !ok { 2784 return fmt.Errorf("unexpected JSON type %v", value) 2785 } 2786 2787 var sv *GetAccountSettingsOutput 2788 if *v == nil { 2789 sv = &GetAccountSettingsOutput{} 2790 } else { 2791 sv = *v 2792 } 2793 2794 for key, value := range shape { 2795 switch key { 2796 case "AccountLimit": 2797 if err := awsRestjson1_deserializeDocumentAccountLimit(&sv.AccountLimit, value); err != nil { 2798 return err 2799 } 2800 2801 case "AccountUsage": 2802 if err := awsRestjson1_deserializeDocumentAccountUsage(&sv.AccountUsage, value); err != nil { 2803 return err 2804 } 2805 2806 default: 2807 _, _ = key, value 2808 2809 } 2810 } 2811 *v = sv 2812 return nil 2813} 2814 2815type awsRestjson1_deserializeOpGetAlias struct { 2816} 2817 2818func (*awsRestjson1_deserializeOpGetAlias) ID() string { 2819 return "OperationDeserializer" 2820} 2821 2822func (m *awsRestjson1_deserializeOpGetAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2823 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2824) { 2825 out, metadata, err = next.HandleDeserialize(ctx, in) 2826 if err != nil { 2827 return out, metadata, err 2828 } 2829 2830 response, ok := out.RawResponse.(*smithyhttp.Response) 2831 if !ok { 2832 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2833 } 2834 2835 if response.StatusCode < 200 || response.StatusCode >= 300 { 2836 return out, metadata, awsRestjson1_deserializeOpErrorGetAlias(response, &metadata) 2837 } 2838 output := &GetAliasOutput{} 2839 out.Result = output 2840 2841 var buff [1024]byte 2842 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2843 2844 body := io.TeeReader(response.Body, ringBuffer) 2845 2846 decoder := json.NewDecoder(body) 2847 decoder.UseNumber() 2848 var shape interface{} 2849 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2850 var snapshot bytes.Buffer 2851 io.Copy(&snapshot, ringBuffer) 2852 err = &smithy.DeserializationError{ 2853 Err: fmt.Errorf("failed to decode response body, %w", err), 2854 Snapshot: snapshot.Bytes(), 2855 } 2856 return out, metadata, err 2857 } 2858 2859 err = awsRestjson1_deserializeOpDocumentGetAliasOutput(&output, shape) 2860 if err != nil { 2861 var snapshot bytes.Buffer 2862 io.Copy(&snapshot, ringBuffer) 2863 return out, metadata, &smithy.DeserializationError{ 2864 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2865 Snapshot: snapshot.Bytes(), 2866 } 2867 } 2868 2869 return out, metadata, err 2870} 2871 2872func awsRestjson1_deserializeOpErrorGetAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2873 var errorBuffer bytes.Buffer 2874 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2875 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2876 } 2877 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2878 2879 errorCode := "UnknownError" 2880 errorMessage := errorCode 2881 2882 code := response.Header.Get("X-Amzn-ErrorType") 2883 if len(code) != 0 { 2884 errorCode = restjson.SanitizeErrorCode(code) 2885 } 2886 2887 var buff [1024]byte 2888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2889 2890 body := io.TeeReader(errorBody, ringBuffer) 2891 decoder := json.NewDecoder(body) 2892 decoder.UseNumber() 2893 code, message, err := restjson.GetErrorInfo(decoder) 2894 if err != nil { 2895 var snapshot bytes.Buffer 2896 io.Copy(&snapshot, ringBuffer) 2897 err = &smithy.DeserializationError{ 2898 Err: fmt.Errorf("failed to decode response body, %w", err), 2899 Snapshot: snapshot.Bytes(), 2900 } 2901 return err 2902 } 2903 2904 errorBody.Seek(0, io.SeekStart) 2905 if len(code) != 0 { 2906 errorCode = restjson.SanitizeErrorCode(code) 2907 } 2908 if len(message) != 0 { 2909 errorMessage = message 2910 } 2911 2912 switch { 2913 case strings.EqualFold("InvalidParameterValueException", errorCode): 2914 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 2915 2916 case strings.EqualFold("ResourceNotFoundException", errorCode): 2917 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2918 2919 case strings.EqualFold("ServiceException", errorCode): 2920 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 2921 2922 case strings.EqualFold("TooManyRequestsException", errorCode): 2923 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2924 2925 default: 2926 genericError := &smithy.GenericAPIError{ 2927 Code: errorCode, 2928 Message: errorMessage, 2929 } 2930 return genericError 2931 2932 } 2933} 2934 2935func awsRestjson1_deserializeOpDocumentGetAliasOutput(v **GetAliasOutput, value interface{}) error { 2936 if v == nil { 2937 return fmt.Errorf("unexpected nil of type %T", v) 2938 } 2939 if value == nil { 2940 return nil 2941 } 2942 2943 shape, ok := value.(map[string]interface{}) 2944 if !ok { 2945 return fmt.Errorf("unexpected JSON type %v", value) 2946 } 2947 2948 var sv *GetAliasOutput 2949 if *v == nil { 2950 sv = &GetAliasOutput{} 2951 } else { 2952 sv = *v 2953 } 2954 2955 for key, value := range shape { 2956 switch key { 2957 case "AliasArn": 2958 if value != nil { 2959 jtv, ok := value.(string) 2960 if !ok { 2961 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 2962 } 2963 sv.AliasArn = ptr.String(jtv) 2964 } 2965 2966 case "Description": 2967 if value != nil { 2968 jtv, ok := value.(string) 2969 if !ok { 2970 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 2971 } 2972 sv.Description = ptr.String(jtv) 2973 } 2974 2975 case "FunctionVersion": 2976 if value != nil { 2977 jtv, ok := value.(string) 2978 if !ok { 2979 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 2980 } 2981 sv.FunctionVersion = ptr.String(jtv) 2982 } 2983 2984 case "Name": 2985 if value != nil { 2986 jtv, ok := value.(string) 2987 if !ok { 2988 return fmt.Errorf("expected Alias to be of type string, got %T instead", value) 2989 } 2990 sv.Name = ptr.String(jtv) 2991 } 2992 2993 case "RevisionId": 2994 if value != nil { 2995 jtv, ok := value.(string) 2996 if !ok { 2997 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2998 } 2999 sv.RevisionId = ptr.String(jtv) 3000 } 3001 3002 case "RoutingConfig": 3003 if err := awsRestjson1_deserializeDocumentAliasRoutingConfiguration(&sv.RoutingConfig, value); err != nil { 3004 return err 3005 } 3006 3007 default: 3008 _, _ = key, value 3009 3010 } 3011 } 3012 *v = sv 3013 return nil 3014} 3015 3016type awsRestjson1_deserializeOpGetCodeSigningConfig struct { 3017} 3018 3019func (*awsRestjson1_deserializeOpGetCodeSigningConfig) ID() string { 3020 return "OperationDeserializer" 3021} 3022 3023func (m *awsRestjson1_deserializeOpGetCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3024 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3025) { 3026 out, metadata, err = next.HandleDeserialize(ctx, in) 3027 if err != nil { 3028 return out, metadata, err 3029 } 3030 3031 response, ok := out.RawResponse.(*smithyhttp.Response) 3032 if !ok { 3033 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3034 } 3035 3036 if response.StatusCode < 200 || response.StatusCode >= 300 { 3037 return out, metadata, awsRestjson1_deserializeOpErrorGetCodeSigningConfig(response, &metadata) 3038 } 3039 output := &GetCodeSigningConfigOutput{} 3040 out.Result = output 3041 3042 var buff [1024]byte 3043 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3044 3045 body := io.TeeReader(response.Body, ringBuffer) 3046 3047 decoder := json.NewDecoder(body) 3048 decoder.UseNumber() 3049 var shape interface{} 3050 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3051 var snapshot bytes.Buffer 3052 io.Copy(&snapshot, ringBuffer) 3053 err = &smithy.DeserializationError{ 3054 Err: fmt.Errorf("failed to decode response body, %w", err), 3055 Snapshot: snapshot.Bytes(), 3056 } 3057 return out, metadata, err 3058 } 3059 3060 err = awsRestjson1_deserializeOpDocumentGetCodeSigningConfigOutput(&output, shape) 3061 if err != nil { 3062 var snapshot bytes.Buffer 3063 io.Copy(&snapshot, ringBuffer) 3064 return out, metadata, &smithy.DeserializationError{ 3065 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3066 Snapshot: snapshot.Bytes(), 3067 } 3068 } 3069 3070 return out, metadata, err 3071} 3072 3073func awsRestjson1_deserializeOpErrorGetCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3074 var errorBuffer bytes.Buffer 3075 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3076 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3077 } 3078 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3079 3080 errorCode := "UnknownError" 3081 errorMessage := errorCode 3082 3083 code := response.Header.Get("X-Amzn-ErrorType") 3084 if len(code) != 0 { 3085 errorCode = restjson.SanitizeErrorCode(code) 3086 } 3087 3088 var buff [1024]byte 3089 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3090 3091 body := io.TeeReader(errorBody, ringBuffer) 3092 decoder := json.NewDecoder(body) 3093 decoder.UseNumber() 3094 code, message, err := restjson.GetErrorInfo(decoder) 3095 if err != nil { 3096 var snapshot bytes.Buffer 3097 io.Copy(&snapshot, ringBuffer) 3098 err = &smithy.DeserializationError{ 3099 Err: fmt.Errorf("failed to decode response body, %w", err), 3100 Snapshot: snapshot.Bytes(), 3101 } 3102 return err 3103 } 3104 3105 errorBody.Seek(0, io.SeekStart) 3106 if len(code) != 0 { 3107 errorCode = restjson.SanitizeErrorCode(code) 3108 } 3109 if len(message) != 0 { 3110 errorMessage = message 3111 } 3112 3113 switch { 3114 case strings.EqualFold("InvalidParameterValueException", errorCode): 3115 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 3116 3117 case strings.EqualFold("ResourceNotFoundException", errorCode): 3118 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3119 3120 case strings.EqualFold("ServiceException", errorCode): 3121 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 3122 3123 default: 3124 genericError := &smithy.GenericAPIError{ 3125 Code: errorCode, 3126 Message: errorMessage, 3127 } 3128 return genericError 3129 3130 } 3131} 3132 3133func awsRestjson1_deserializeOpDocumentGetCodeSigningConfigOutput(v **GetCodeSigningConfigOutput, value interface{}) error { 3134 if v == nil { 3135 return fmt.Errorf("unexpected nil of type %T", v) 3136 } 3137 if value == nil { 3138 return nil 3139 } 3140 3141 shape, ok := value.(map[string]interface{}) 3142 if !ok { 3143 return fmt.Errorf("unexpected JSON type %v", value) 3144 } 3145 3146 var sv *GetCodeSigningConfigOutput 3147 if *v == nil { 3148 sv = &GetCodeSigningConfigOutput{} 3149 } else { 3150 sv = *v 3151 } 3152 3153 for key, value := range shape { 3154 switch key { 3155 case "CodeSigningConfig": 3156 if err := awsRestjson1_deserializeDocumentCodeSigningConfig(&sv.CodeSigningConfig, value); err != nil { 3157 return err 3158 } 3159 3160 default: 3161 _, _ = key, value 3162 3163 } 3164 } 3165 *v = sv 3166 return nil 3167} 3168 3169type awsRestjson1_deserializeOpGetEventSourceMapping struct { 3170} 3171 3172func (*awsRestjson1_deserializeOpGetEventSourceMapping) ID() string { 3173 return "OperationDeserializer" 3174} 3175 3176func (m *awsRestjson1_deserializeOpGetEventSourceMapping) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3177 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3178) { 3179 out, metadata, err = next.HandleDeserialize(ctx, in) 3180 if err != nil { 3181 return out, metadata, err 3182 } 3183 3184 response, ok := out.RawResponse.(*smithyhttp.Response) 3185 if !ok { 3186 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3187 } 3188 3189 if response.StatusCode < 200 || response.StatusCode >= 300 { 3190 return out, metadata, awsRestjson1_deserializeOpErrorGetEventSourceMapping(response, &metadata) 3191 } 3192 output := &GetEventSourceMappingOutput{} 3193 out.Result = output 3194 3195 var buff [1024]byte 3196 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3197 3198 body := io.TeeReader(response.Body, ringBuffer) 3199 3200 decoder := json.NewDecoder(body) 3201 decoder.UseNumber() 3202 var shape interface{} 3203 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3204 var snapshot bytes.Buffer 3205 io.Copy(&snapshot, ringBuffer) 3206 err = &smithy.DeserializationError{ 3207 Err: fmt.Errorf("failed to decode response body, %w", err), 3208 Snapshot: snapshot.Bytes(), 3209 } 3210 return out, metadata, err 3211 } 3212 3213 err = awsRestjson1_deserializeOpDocumentGetEventSourceMappingOutput(&output, shape) 3214 if err != nil { 3215 var snapshot bytes.Buffer 3216 io.Copy(&snapshot, ringBuffer) 3217 return out, metadata, &smithy.DeserializationError{ 3218 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3219 Snapshot: snapshot.Bytes(), 3220 } 3221 } 3222 3223 return out, metadata, err 3224} 3225 3226func awsRestjson1_deserializeOpErrorGetEventSourceMapping(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3227 var errorBuffer bytes.Buffer 3228 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3229 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3230 } 3231 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3232 3233 errorCode := "UnknownError" 3234 errorMessage := errorCode 3235 3236 code := response.Header.Get("X-Amzn-ErrorType") 3237 if len(code) != 0 { 3238 errorCode = restjson.SanitizeErrorCode(code) 3239 } 3240 3241 var buff [1024]byte 3242 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3243 3244 body := io.TeeReader(errorBody, ringBuffer) 3245 decoder := json.NewDecoder(body) 3246 decoder.UseNumber() 3247 code, message, err := restjson.GetErrorInfo(decoder) 3248 if err != nil { 3249 var snapshot bytes.Buffer 3250 io.Copy(&snapshot, ringBuffer) 3251 err = &smithy.DeserializationError{ 3252 Err: fmt.Errorf("failed to decode response body, %w", err), 3253 Snapshot: snapshot.Bytes(), 3254 } 3255 return err 3256 } 3257 3258 errorBody.Seek(0, io.SeekStart) 3259 if len(code) != 0 { 3260 errorCode = restjson.SanitizeErrorCode(code) 3261 } 3262 if len(message) != 0 { 3263 errorMessage = message 3264 } 3265 3266 switch { 3267 case strings.EqualFold("InvalidParameterValueException", errorCode): 3268 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 3269 3270 case strings.EqualFold("ResourceNotFoundException", errorCode): 3271 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3272 3273 case strings.EqualFold("ServiceException", errorCode): 3274 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 3275 3276 case strings.EqualFold("TooManyRequestsException", errorCode): 3277 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3278 3279 default: 3280 genericError := &smithy.GenericAPIError{ 3281 Code: errorCode, 3282 Message: errorMessage, 3283 } 3284 return genericError 3285 3286 } 3287} 3288 3289func awsRestjson1_deserializeOpDocumentGetEventSourceMappingOutput(v **GetEventSourceMappingOutput, value interface{}) error { 3290 if v == nil { 3291 return fmt.Errorf("unexpected nil of type %T", v) 3292 } 3293 if value == nil { 3294 return nil 3295 } 3296 3297 shape, ok := value.(map[string]interface{}) 3298 if !ok { 3299 return fmt.Errorf("unexpected JSON type %v", value) 3300 } 3301 3302 var sv *GetEventSourceMappingOutput 3303 if *v == nil { 3304 sv = &GetEventSourceMappingOutput{} 3305 } else { 3306 sv = *v 3307 } 3308 3309 for key, value := range shape { 3310 switch key { 3311 case "BatchSize": 3312 if value != nil { 3313 jtv, ok := value.(json.Number) 3314 if !ok { 3315 return fmt.Errorf("expected BatchSize to be json.Number, got %T instead", value) 3316 } 3317 i64, err := jtv.Int64() 3318 if err != nil { 3319 return err 3320 } 3321 sv.BatchSize = ptr.Int32(int32(i64)) 3322 } 3323 3324 case "BisectBatchOnFunctionError": 3325 if value != nil { 3326 jtv, ok := value.(bool) 3327 if !ok { 3328 return fmt.Errorf("expected BisectBatchOnFunctionError to be of type *bool, got %T instead", value) 3329 } 3330 sv.BisectBatchOnFunctionError = ptr.Bool(jtv) 3331 } 3332 3333 case "DestinationConfig": 3334 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 3335 return err 3336 } 3337 3338 case "EventSourceArn": 3339 if value != nil { 3340 jtv, ok := value.(string) 3341 if !ok { 3342 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3343 } 3344 sv.EventSourceArn = ptr.String(jtv) 3345 } 3346 3347 case "FunctionArn": 3348 if value != nil { 3349 jtv, ok := value.(string) 3350 if !ok { 3351 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 3352 } 3353 sv.FunctionArn = ptr.String(jtv) 3354 } 3355 3356 case "FunctionResponseTypes": 3357 if err := awsRestjson1_deserializeDocumentFunctionResponseTypeList(&sv.FunctionResponseTypes, value); err != nil { 3358 return err 3359 } 3360 3361 case "LastModified": 3362 if value != nil { 3363 jtv, ok := value.(json.Number) 3364 if !ok { 3365 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 3366 } 3367 f64, err := jtv.Float64() 3368 if err != nil { 3369 return err 3370 } 3371 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3372 } 3373 3374 case "LastProcessingResult": 3375 if value != nil { 3376 jtv, ok := value.(string) 3377 if !ok { 3378 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3379 } 3380 sv.LastProcessingResult = ptr.String(jtv) 3381 } 3382 3383 case "MaximumBatchingWindowInSeconds": 3384 if value != nil { 3385 jtv, ok := value.(json.Number) 3386 if !ok { 3387 return fmt.Errorf("expected MaximumBatchingWindowInSeconds to be json.Number, got %T instead", value) 3388 } 3389 i64, err := jtv.Int64() 3390 if err != nil { 3391 return err 3392 } 3393 sv.MaximumBatchingWindowInSeconds = ptr.Int32(int32(i64)) 3394 } 3395 3396 case "MaximumRecordAgeInSeconds": 3397 if value != nil { 3398 jtv, ok := value.(json.Number) 3399 if !ok { 3400 return fmt.Errorf("expected MaximumRecordAgeInSeconds to be json.Number, got %T instead", value) 3401 } 3402 i64, err := jtv.Int64() 3403 if err != nil { 3404 return err 3405 } 3406 sv.MaximumRecordAgeInSeconds = ptr.Int32(int32(i64)) 3407 } 3408 3409 case "MaximumRetryAttempts": 3410 if value != nil { 3411 jtv, ok := value.(json.Number) 3412 if !ok { 3413 return fmt.Errorf("expected MaximumRetryAttemptsEventSourceMapping to be json.Number, got %T instead", value) 3414 } 3415 i64, err := jtv.Int64() 3416 if err != nil { 3417 return err 3418 } 3419 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 3420 } 3421 3422 case "ParallelizationFactor": 3423 if value != nil { 3424 jtv, ok := value.(json.Number) 3425 if !ok { 3426 return fmt.Errorf("expected ParallelizationFactor to be json.Number, got %T instead", value) 3427 } 3428 i64, err := jtv.Int64() 3429 if err != nil { 3430 return err 3431 } 3432 sv.ParallelizationFactor = ptr.Int32(int32(i64)) 3433 } 3434 3435 case "Queues": 3436 if err := awsRestjson1_deserializeDocumentQueues(&sv.Queues, value); err != nil { 3437 return err 3438 } 3439 3440 case "SelfManagedEventSource": 3441 if err := awsRestjson1_deserializeDocumentSelfManagedEventSource(&sv.SelfManagedEventSource, value); err != nil { 3442 return err 3443 } 3444 3445 case "SourceAccessConfigurations": 3446 if err := awsRestjson1_deserializeDocumentSourceAccessConfigurations(&sv.SourceAccessConfigurations, value); err != nil { 3447 return err 3448 } 3449 3450 case "StartingPosition": 3451 if value != nil { 3452 jtv, ok := value.(string) 3453 if !ok { 3454 return fmt.Errorf("expected EventSourcePosition to be of type string, got %T instead", value) 3455 } 3456 sv.StartingPosition = types.EventSourcePosition(jtv) 3457 } 3458 3459 case "StartingPositionTimestamp": 3460 if value != nil { 3461 jtv, ok := value.(json.Number) 3462 if !ok { 3463 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 3464 } 3465 f64, err := jtv.Float64() 3466 if err != nil { 3467 return err 3468 } 3469 sv.StartingPositionTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3470 } 3471 3472 case "State": 3473 if value != nil { 3474 jtv, ok := value.(string) 3475 if !ok { 3476 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3477 } 3478 sv.State = ptr.String(jtv) 3479 } 3480 3481 case "StateTransitionReason": 3482 if value != nil { 3483 jtv, ok := value.(string) 3484 if !ok { 3485 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3486 } 3487 sv.StateTransitionReason = ptr.String(jtv) 3488 } 3489 3490 case "Topics": 3491 if err := awsRestjson1_deserializeDocumentTopics(&sv.Topics, value); err != nil { 3492 return err 3493 } 3494 3495 case "TumblingWindowInSeconds": 3496 if value != nil { 3497 jtv, ok := value.(json.Number) 3498 if !ok { 3499 return fmt.Errorf("expected TumblingWindowInSeconds to be json.Number, got %T instead", value) 3500 } 3501 i64, err := jtv.Int64() 3502 if err != nil { 3503 return err 3504 } 3505 sv.TumblingWindowInSeconds = ptr.Int32(int32(i64)) 3506 } 3507 3508 case "UUID": 3509 if value != nil { 3510 jtv, ok := value.(string) 3511 if !ok { 3512 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3513 } 3514 sv.UUID = ptr.String(jtv) 3515 } 3516 3517 default: 3518 _, _ = key, value 3519 3520 } 3521 } 3522 *v = sv 3523 return nil 3524} 3525 3526type awsRestjson1_deserializeOpGetFunction struct { 3527} 3528 3529func (*awsRestjson1_deserializeOpGetFunction) ID() string { 3530 return "OperationDeserializer" 3531} 3532 3533func (m *awsRestjson1_deserializeOpGetFunction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3534 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3535) { 3536 out, metadata, err = next.HandleDeserialize(ctx, in) 3537 if err != nil { 3538 return out, metadata, err 3539 } 3540 3541 response, ok := out.RawResponse.(*smithyhttp.Response) 3542 if !ok { 3543 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3544 } 3545 3546 if response.StatusCode < 200 || response.StatusCode >= 300 { 3547 return out, metadata, awsRestjson1_deserializeOpErrorGetFunction(response, &metadata) 3548 } 3549 output := &GetFunctionOutput{} 3550 out.Result = output 3551 3552 var buff [1024]byte 3553 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3554 3555 body := io.TeeReader(response.Body, ringBuffer) 3556 3557 decoder := json.NewDecoder(body) 3558 decoder.UseNumber() 3559 var shape interface{} 3560 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3561 var snapshot bytes.Buffer 3562 io.Copy(&snapshot, ringBuffer) 3563 err = &smithy.DeserializationError{ 3564 Err: fmt.Errorf("failed to decode response body, %w", err), 3565 Snapshot: snapshot.Bytes(), 3566 } 3567 return out, metadata, err 3568 } 3569 3570 err = awsRestjson1_deserializeOpDocumentGetFunctionOutput(&output, shape) 3571 if err != nil { 3572 var snapshot bytes.Buffer 3573 io.Copy(&snapshot, ringBuffer) 3574 return out, metadata, &smithy.DeserializationError{ 3575 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3576 Snapshot: snapshot.Bytes(), 3577 } 3578 } 3579 3580 return out, metadata, err 3581} 3582 3583func awsRestjson1_deserializeOpErrorGetFunction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3584 var errorBuffer bytes.Buffer 3585 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3586 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3587 } 3588 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3589 3590 errorCode := "UnknownError" 3591 errorMessage := errorCode 3592 3593 code := response.Header.Get("X-Amzn-ErrorType") 3594 if len(code) != 0 { 3595 errorCode = restjson.SanitizeErrorCode(code) 3596 } 3597 3598 var buff [1024]byte 3599 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3600 3601 body := io.TeeReader(errorBody, ringBuffer) 3602 decoder := json.NewDecoder(body) 3603 decoder.UseNumber() 3604 code, message, err := restjson.GetErrorInfo(decoder) 3605 if err != nil { 3606 var snapshot bytes.Buffer 3607 io.Copy(&snapshot, ringBuffer) 3608 err = &smithy.DeserializationError{ 3609 Err: fmt.Errorf("failed to decode response body, %w", err), 3610 Snapshot: snapshot.Bytes(), 3611 } 3612 return err 3613 } 3614 3615 errorBody.Seek(0, io.SeekStart) 3616 if len(code) != 0 { 3617 errorCode = restjson.SanitizeErrorCode(code) 3618 } 3619 if len(message) != 0 { 3620 errorMessage = message 3621 } 3622 3623 switch { 3624 case strings.EqualFold("InvalidParameterValueException", errorCode): 3625 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 3626 3627 case strings.EqualFold("ResourceNotFoundException", errorCode): 3628 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3629 3630 case strings.EqualFold("ServiceException", errorCode): 3631 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 3632 3633 case strings.EqualFold("TooManyRequestsException", errorCode): 3634 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3635 3636 default: 3637 genericError := &smithy.GenericAPIError{ 3638 Code: errorCode, 3639 Message: errorMessage, 3640 } 3641 return genericError 3642 3643 } 3644} 3645 3646func awsRestjson1_deserializeOpDocumentGetFunctionOutput(v **GetFunctionOutput, value interface{}) error { 3647 if v == nil { 3648 return fmt.Errorf("unexpected nil of type %T", v) 3649 } 3650 if value == nil { 3651 return nil 3652 } 3653 3654 shape, ok := value.(map[string]interface{}) 3655 if !ok { 3656 return fmt.Errorf("unexpected JSON type %v", value) 3657 } 3658 3659 var sv *GetFunctionOutput 3660 if *v == nil { 3661 sv = &GetFunctionOutput{} 3662 } else { 3663 sv = *v 3664 } 3665 3666 for key, value := range shape { 3667 switch key { 3668 case "Code": 3669 if err := awsRestjson1_deserializeDocumentFunctionCodeLocation(&sv.Code, value); err != nil { 3670 return err 3671 } 3672 3673 case "Concurrency": 3674 if err := awsRestjson1_deserializeDocumentConcurrency(&sv.Concurrency, value); err != nil { 3675 return err 3676 } 3677 3678 case "Configuration": 3679 if err := awsRestjson1_deserializeDocumentFunctionConfiguration(&sv.Configuration, value); err != nil { 3680 return err 3681 } 3682 3683 case "Tags": 3684 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 3685 return err 3686 } 3687 3688 default: 3689 _, _ = key, value 3690 3691 } 3692 } 3693 *v = sv 3694 return nil 3695} 3696 3697type awsRestjson1_deserializeOpGetFunctionCodeSigningConfig struct { 3698} 3699 3700func (*awsRestjson1_deserializeOpGetFunctionCodeSigningConfig) ID() string { 3701 return "OperationDeserializer" 3702} 3703 3704func (m *awsRestjson1_deserializeOpGetFunctionCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3705 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3706) { 3707 out, metadata, err = next.HandleDeserialize(ctx, in) 3708 if err != nil { 3709 return out, metadata, err 3710 } 3711 3712 response, ok := out.RawResponse.(*smithyhttp.Response) 3713 if !ok { 3714 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3715 } 3716 3717 if response.StatusCode < 200 || response.StatusCode >= 300 { 3718 return out, metadata, awsRestjson1_deserializeOpErrorGetFunctionCodeSigningConfig(response, &metadata) 3719 } 3720 output := &GetFunctionCodeSigningConfigOutput{} 3721 out.Result = output 3722 3723 var buff [1024]byte 3724 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3725 3726 body := io.TeeReader(response.Body, ringBuffer) 3727 3728 decoder := json.NewDecoder(body) 3729 decoder.UseNumber() 3730 var shape interface{} 3731 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3732 var snapshot bytes.Buffer 3733 io.Copy(&snapshot, ringBuffer) 3734 err = &smithy.DeserializationError{ 3735 Err: fmt.Errorf("failed to decode response body, %w", err), 3736 Snapshot: snapshot.Bytes(), 3737 } 3738 return out, metadata, err 3739 } 3740 3741 err = awsRestjson1_deserializeOpDocumentGetFunctionCodeSigningConfigOutput(&output, shape) 3742 if err != nil { 3743 var snapshot bytes.Buffer 3744 io.Copy(&snapshot, ringBuffer) 3745 return out, metadata, &smithy.DeserializationError{ 3746 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3747 Snapshot: snapshot.Bytes(), 3748 } 3749 } 3750 3751 return out, metadata, err 3752} 3753 3754func awsRestjson1_deserializeOpErrorGetFunctionCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3755 var errorBuffer bytes.Buffer 3756 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3757 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3758 } 3759 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3760 3761 errorCode := "UnknownError" 3762 errorMessage := errorCode 3763 3764 code := response.Header.Get("X-Amzn-ErrorType") 3765 if len(code) != 0 { 3766 errorCode = restjson.SanitizeErrorCode(code) 3767 } 3768 3769 var buff [1024]byte 3770 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3771 3772 body := io.TeeReader(errorBody, ringBuffer) 3773 decoder := json.NewDecoder(body) 3774 decoder.UseNumber() 3775 code, message, err := restjson.GetErrorInfo(decoder) 3776 if err != nil { 3777 var snapshot bytes.Buffer 3778 io.Copy(&snapshot, ringBuffer) 3779 err = &smithy.DeserializationError{ 3780 Err: fmt.Errorf("failed to decode response body, %w", err), 3781 Snapshot: snapshot.Bytes(), 3782 } 3783 return err 3784 } 3785 3786 errorBody.Seek(0, io.SeekStart) 3787 if len(code) != 0 { 3788 errorCode = restjson.SanitizeErrorCode(code) 3789 } 3790 if len(message) != 0 { 3791 errorMessage = message 3792 } 3793 3794 switch { 3795 case strings.EqualFold("InvalidParameterValueException", errorCode): 3796 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 3797 3798 case strings.EqualFold("ResourceNotFoundException", errorCode): 3799 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3800 3801 case strings.EqualFold("ServiceException", errorCode): 3802 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 3803 3804 case strings.EqualFold("TooManyRequestsException", errorCode): 3805 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3806 3807 default: 3808 genericError := &smithy.GenericAPIError{ 3809 Code: errorCode, 3810 Message: errorMessage, 3811 } 3812 return genericError 3813 3814 } 3815} 3816 3817func awsRestjson1_deserializeOpDocumentGetFunctionCodeSigningConfigOutput(v **GetFunctionCodeSigningConfigOutput, value interface{}) error { 3818 if v == nil { 3819 return fmt.Errorf("unexpected nil of type %T", v) 3820 } 3821 if value == nil { 3822 return nil 3823 } 3824 3825 shape, ok := value.(map[string]interface{}) 3826 if !ok { 3827 return fmt.Errorf("unexpected JSON type %v", value) 3828 } 3829 3830 var sv *GetFunctionCodeSigningConfigOutput 3831 if *v == nil { 3832 sv = &GetFunctionCodeSigningConfigOutput{} 3833 } else { 3834 sv = *v 3835 } 3836 3837 for key, value := range shape { 3838 switch key { 3839 case "CodeSigningConfigArn": 3840 if value != nil { 3841 jtv, ok := value.(string) 3842 if !ok { 3843 return fmt.Errorf("expected CodeSigningConfigArn to be of type string, got %T instead", value) 3844 } 3845 sv.CodeSigningConfigArn = ptr.String(jtv) 3846 } 3847 3848 case "FunctionName": 3849 if value != nil { 3850 jtv, ok := value.(string) 3851 if !ok { 3852 return fmt.Errorf("expected FunctionName to be of type string, got %T instead", value) 3853 } 3854 sv.FunctionName = ptr.String(jtv) 3855 } 3856 3857 default: 3858 _, _ = key, value 3859 3860 } 3861 } 3862 *v = sv 3863 return nil 3864} 3865 3866type awsRestjson1_deserializeOpGetFunctionConcurrency struct { 3867} 3868 3869func (*awsRestjson1_deserializeOpGetFunctionConcurrency) ID() string { 3870 return "OperationDeserializer" 3871} 3872 3873func (m *awsRestjson1_deserializeOpGetFunctionConcurrency) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3874 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3875) { 3876 out, metadata, err = next.HandleDeserialize(ctx, in) 3877 if err != nil { 3878 return out, metadata, err 3879 } 3880 3881 response, ok := out.RawResponse.(*smithyhttp.Response) 3882 if !ok { 3883 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3884 } 3885 3886 if response.StatusCode < 200 || response.StatusCode >= 300 { 3887 return out, metadata, awsRestjson1_deserializeOpErrorGetFunctionConcurrency(response, &metadata) 3888 } 3889 output := &GetFunctionConcurrencyOutput{} 3890 out.Result = output 3891 3892 var buff [1024]byte 3893 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3894 3895 body := io.TeeReader(response.Body, ringBuffer) 3896 3897 decoder := json.NewDecoder(body) 3898 decoder.UseNumber() 3899 var shape interface{} 3900 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3901 var snapshot bytes.Buffer 3902 io.Copy(&snapshot, ringBuffer) 3903 err = &smithy.DeserializationError{ 3904 Err: fmt.Errorf("failed to decode response body, %w", err), 3905 Snapshot: snapshot.Bytes(), 3906 } 3907 return out, metadata, err 3908 } 3909 3910 err = awsRestjson1_deserializeOpDocumentGetFunctionConcurrencyOutput(&output, shape) 3911 if err != nil { 3912 var snapshot bytes.Buffer 3913 io.Copy(&snapshot, ringBuffer) 3914 return out, metadata, &smithy.DeserializationError{ 3915 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3916 Snapshot: snapshot.Bytes(), 3917 } 3918 } 3919 3920 return out, metadata, err 3921} 3922 3923func awsRestjson1_deserializeOpErrorGetFunctionConcurrency(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3924 var errorBuffer bytes.Buffer 3925 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3926 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3927 } 3928 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3929 3930 errorCode := "UnknownError" 3931 errorMessage := errorCode 3932 3933 code := response.Header.Get("X-Amzn-ErrorType") 3934 if len(code) != 0 { 3935 errorCode = restjson.SanitizeErrorCode(code) 3936 } 3937 3938 var buff [1024]byte 3939 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3940 3941 body := io.TeeReader(errorBody, ringBuffer) 3942 decoder := json.NewDecoder(body) 3943 decoder.UseNumber() 3944 code, message, err := restjson.GetErrorInfo(decoder) 3945 if err != nil { 3946 var snapshot bytes.Buffer 3947 io.Copy(&snapshot, ringBuffer) 3948 err = &smithy.DeserializationError{ 3949 Err: fmt.Errorf("failed to decode response body, %w", err), 3950 Snapshot: snapshot.Bytes(), 3951 } 3952 return err 3953 } 3954 3955 errorBody.Seek(0, io.SeekStart) 3956 if len(code) != 0 { 3957 errorCode = restjson.SanitizeErrorCode(code) 3958 } 3959 if len(message) != 0 { 3960 errorMessage = message 3961 } 3962 3963 switch { 3964 case strings.EqualFold("InvalidParameterValueException", errorCode): 3965 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 3966 3967 case strings.EqualFold("ResourceNotFoundException", errorCode): 3968 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3969 3970 case strings.EqualFold("ServiceException", errorCode): 3971 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 3972 3973 case strings.EqualFold("TooManyRequestsException", errorCode): 3974 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3975 3976 default: 3977 genericError := &smithy.GenericAPIError{ 3978 Code: errorCode, 3979 Message: errorMessage, 3980 } 3981 return genericError 3982 3983 } 3984} 3985 3986func awsRestjson1_deserializeOpDocumentGetFunctionConcurrencyOutput(v **GetFunctionConcurrencyOutput, value interface{}) error { 3987 if v == nil { 3988 return fmt.Errorf("unexpected nil of type %T", v) 3989 } 3990 if value == nil { 3991 return nil 3992 } 3993 3994 shape, ok := value.(map[string]interface{}) 3995 if !ok { 3996 return fmt.Errorf("unexpected JSON type %v", value) 3997 } 3998 3999 var sv *GetFunctionConcurrencyOutput 4000 if *v == nil { 4001 sv = &GetFunctionConcurrencyOutput{} 4002 } else { 4003 sv = *v 4004 } 4005 4006 for key, value := range shape { 4007 switch key { 4008 case "ReservedConcurrentExecutions": 4009 if value != nil { 4010 jtv, ok := value.(json.Number) 4011 if !ok { 4012 return fmt.Errorf("expected ReservedConcurrentExecutions to be json.Number, got %T instead", value) 4013 } 4014 i64, err := jtv.Int64() 4015 if err != nil { 4016 return err 4017 } 4018 sv.ReservedConcurrentExecutions = ptr.Int32(int32(i64)) 4019 } 4020 4021 default: 4022 _, _ = key, value 4023 4024 } 4025 } 4026 *v = sv 4027 return nil 4028} 4029 4030type awsRestjson1_deserializeOpGetFunctionConfiguration struct { 4031} 4032 4033func (*awsRestjson1_deserializeOpGetFunctionConfiguration) ID() string { 4034 return "OperationDeserializer" 4035} 4036 4037func (m *awsRestjson1_deserializeOpGetFunctionConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4038 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4039) { 4040 out, metadata, err = next.HandleDeserialize(ctx, in) 4041 if err != nil { 4042 return out, metadata, err 4043 } 4044 4045 response, ok := out.RawResponse.(*smithyhttp.Response) 4046 if !ok { 4047 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4048 } 4049 4050 if response.StatusCode < 200 || response.StatusCode >= 300 { 4051 return out, metadata, awsRestjson1_deserializeOpErrorGetFunctionConfiguration(response, &metadata) 4052 } 4053 output := &GetFunctionConfigurationOutput{} 4054 out.Result = output 4055 4056 var buff [1024]byte 4057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4058 4059 body := io.TeeReader(response.Body, ringBuffer) 4060 4061 decoder := json.NewDecoder(body) 4062 decoder.UseNumber() 4063 var shape interface{} 4064 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4065 var snapshot bytes.Buffer 4066 io.Copy(&snapshot, ringBuffer) 4067 err = &smithy.DeserializationError{ 4068 Err: fmt.Errorf("failed to decode response body, %w", err), 4069 Snapshot: snapshot.Bytes(), 4070 } 4071 return out, metadata, err 4072 } 4073 4074 err = awsRestjson1_deserializeOpDocumentGetFunctionConfigurationOutput(&output, shape) 4075 if err != nil { 4076 var snapshot bytes.Buffer 4077 io.Copy(&snapshot, ringBuffer) 4078 return out, metadata, &smithy.DeserializationError{ 4079 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4080 Snapshot: snapshot.Bytes(), 4081 } 4082 } 4083 4084 return out, metadata, err 4085} 4086 4087func awsRestjson1_deserializeOpErrorGetFunctionConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4088 var errorBuffer bytes.Buffer 4089 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4090 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4091 } 4092 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4093 4094 errorCode := "UnknownError" 4095 errorMessage := errorCode 4096 4097 code := response.Header.Get("X-Amzn-ErrorType") 4098 if len(code) != 0 { 4099 errorCode = restjson.SanitizeErrorCode(code) 4100 } 4101 4102 var buff [1024]byte 4103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4104 4105 body := io.TeeReader(errorBody, ringBuffer) 4106 decoder := json.NewDecoder(body) 4107 decoder.UseNumber() 4108 code, message, err := restjson.GetErrorInfo(decoder) 4109 if err != nil { 4110 var snapshot bytes.Buffer 4111 io.Copy(&snapshot, ringBuffer) 4112 err = &smithy.DeserializationError{ 4113 Err: fmt.Errorf("failed to decode response body, %w", err), 4114 Snapshot: snapshot.Bytes(), 4115 } 4116 return err 4117 } 4118 4119 errorBody.Seek(0, io.SeekStart) 4120 if len(code) != 0 { 4121 errorCode = restjson.SanitizeErrorCode(code) 4122 } 4123 if len(message) != 0 { 4124 errorMessage = message 4125 } 4126 4127 switch { 4128 case strings.EqualFold("InvalidParameterValueException", errorCode): 4129 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 4130 4131 case strings.EqualFold("ResourceNotFoundException", errorCode): 4132 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4133 4134 case strings.EqualFold("ServiceException", errorCode): 4135 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 4136 4137 case strings.EqualFold("TooManyRequestsException", errorCode): 4138 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4139 4140 default: 4141 genericError := &smithy.GenericAPIError{ 4142 Code: errorCode, 4143 Message: errorMessage, 4144 } 4145 return genericError 4146 4147 } 4148} 4149 4150func awsRestjson1_deserializeOpDocumentGetFunctionConfigurationOutput(v **GetFunctionConfigurationOutput, value interface{}) error { 4151 if v == nil { 4152 return fmt.Errorf("unexpected nil of type %T", v) 4153 } 4154 if value == nil { 4155 return nil 4156 } 4157 4158 shape, ok := value.(map[string]interface{}) 4159 if !ok { 4160 return fmt.Errorf("unexpected JSON type %v", value) 4161 } 4162 4163 var sv *GetFunctionConfigurationOutput 4164 if *v == nil { 4165 sv = &GetFunctionConfigurationOutput{} 4166 } else { 4167 sv = *v 4168 } 4169 4170 for key, value := range shape { 4171 switch key { 4172 case "CodeSha256": 4173 if value != nil { 4174 jtv, ok := value.(string) 4175 if !ok { 4176 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4177 } 4178 sv.CodeSha256 = ptr.String(jtv) 4179 } 4180 4181 case "CodeSize": 4182 if value != nil { 4183 jtv, ok := value.(json.Number) 4184 if !ok { 4185 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 4186 } 4187 i64, err := jtv.Int64() 4188 if err != nil { 4189 return err 4190 } 4191 sv.CodeSize = i64 4192 } 4193 4194 case "DeadLetterConfig": 4195 if err := awsRestjson1_deserializeDocumentDeadLetterConfig(&sv.DeadLetterConfig, value); err != nil { 4196 return err 4197 } 4198 4199 case "Description": 4200 if value != nil { 4201 jtv, ok := value.(string) 4202 if !ok { 4203 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 4204 } 4205 sv.Description = ptr.String(jtv) 4206 } 4207 4208 case "Environment": 4209 if err := awsRestjson1_deserializeDocumentEnvironmentResponse(&sv.Environment, value); err != nil { 4210 return err 4211 } 4212 4213 case "FileSystemConfigs": 4214 if err := awsRestjson1_deserializeDocumentFileSystemConfigList(&sv.FileSystemConfigs, value); err != nil { 4215 return err 4216 } 4217 4218 case "FunctionArn": 4219 if value != nil { 4220 jtv, ok := value.(string) 4221 if !ok { 4222 return fmt.Errorf("expected NameSpacedFunctionArn to be of type string, got %T instead", value) 4223 } 4224 sv.FunctionArn = ptr.String(jtv) 4225 } 4226 4227 case "FunctionName": 4228 if value != nil { 4229 jtv, ok := value.(string) 4230 if !ok { 4231 return fmt.Errorf("expected NamespacedFunctionName to be of type string, got %T instead", value) 4232 } 4233 sv.FunctionName = ptr.String(jtv) 4234 } 4235 4236 case "Handler": 4237 if value != nil { 4238 jtv, ok := value.(string) 4239 if !ok { 4240 return fmt.Errorf("expected Handler to be of type string, got %T instead", value) 4241 } 4242 sv.Handler = ptr.String(jtv) 4243 } 4244 4245 case "ImageConfigResponse": 4246 if err := awsRestjson1_deserializeDocumentImageConfigResponse(&sv.ImageConfigResponse, value); err != nil { 4247 return err 4248 } 4249 4250 case "KMSKeyArn": 4251 if value != nil { 4252 jtv, ok := value.(string) 4253 if !ok { 4254 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 4255 } 4256 sv.KMSKeyArn = ptr.String(jtv) 4257 } 4258 4259 case "LastModified": 4260 if value != nil { 4261 jtv, ok := value.(string) 4262 if !ok { 4263 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 4264 } 4265 sv.LastModified = ptr.String(jtv) 4266 } 4267 4268 case "LastUpdateStatus": 4269 if value != nil { 4270 jtv, ok := value.(string) 4271 if !ok { 4272 return fmt.Errorf("expected LastUpdateStatus to be of type string, got %T instead", value) 4273 } 4274 sv.LastUpdateStatus = types.LastUpdateStatus(jtv) 4275 } 4276 4277 case "LastUpdateStatusReason": 4278 if value != nil { 4279 jtv, ok := value.(string) 4280 if !ok { 4281 return fmt.Errorf("expected LastUpdateStatusReason to be of type string, got %T instead", value) 4282 } 4283 sv.LastUpdateStatusReason = ptr.String(jtv) 4284 } 4285 4286 case "LastUpdateStatusReasonCode": 4287 if value != nil { 4288 jtv, ok := value.(string) 4289 if !ok { 4290 return fmt.Errorf("expected LastUpdateStatusReasonCode to be of type string, got %T instead", value) 4291 } 4292 sv.LastUpdateStatusReasonCode = types.LastUpdateStatusReasonCode(jtv) 4293 } 4294 4295 case "Layers": 4296 if err := awsRestjson1_deserializeDocumentLayersReferenceList(&sv.Layers, value); err != nil { 4297 return err 4298 } 4299 4300 case "MasterArn": 4301 if value != nil { 4302 jtv, ok := value.(string) 4303 if !ok { 4304 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 4305 } 4306 sv.MasterArn = ptr.String(jtv) 4307 } 4308 4309 case "MemorySize": 4310 if value != nil { 4311 jtv, ok := value.(json.Number) 4312 if !ok { 4313 return fmt.Errorf("expected MemorySize to be json.Number, got %T instead", value) 4314 } 4315 i64, err := jtv.Int64() 4316 if err != nil { 4317 return err 4318 } 4319 sv.MemorySize = ptr.Int32(int32(i64)) 4320 } 4321 4322 case "PackageType": 4323 if value != nil { 4324 jtv, ok := value.(string) 4325 if !ok { 4326 return fmt.Errorf("expected PackageType to be of type string, got %T instead", value) 4327 } 4328 sv.PackageType = types.PackageType(jtv) 4329 } 4330 4331 case "RevisionId": 4332 if value != nil { 4333 jtv, ok := value.(string) 4334 if !ok { 4335 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4336 } 4337 sv.RevisionId = ptr.String(jtv) 4338 } 4339 4340 case "Role": 4341 if value != nil { 4342 jtv, ok := value.(string) 4343 if !ok { 4344 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 4345 } 4346 sv.Role = ptr.String(jtv) 4347 } 4348 4349 case "Runtime": 4350 if value != nil { 4351 jtv, ok := value.(string) 4352 if !ok { 4353 return fmt.Errorf("expected Runtime to be of type string, got %T instead", value) 4354 } 4355 sv.Runtime = types.Runtime(jtv) 4356 } 4357 4358 case "SigningJobArn": 4359 if value != nil { 4360 jtv, ok := value.(string) 4361 if !ok { 4362 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4363 } 4364 sv.SigningJobArn = ptr.String(jtv) 4365 } 4366 4367 case "SigningProfileVersionArn": 4368 if value != nil { 4369 jtv, ok := value.(string) 4370 if !ok { 4371 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4372 } 4373 sv.SigningProfileVersionArn = ptr.String(jtv) 4374 } 4375 4376 case "State": 4377 if value != nil { 4378 jtv, ok := value.(string) 4379 if !ok { 4380 return fmt.Errorf("expected State to be of type string, got %T instead", value) 4381 } 4382 sv.State = types.State(jtv) 4383 } 4384 4385 case "StateReason": 4386 if value != nil { 4387 jtv, ok := value.(string) 4388 if !ok { 4389 return fmt.Errorf("expected StateReason to be of type string, got %T instead", value) 4390 } 4391 sv.StateReason = ptr.String(jtv) 4392 } 4393 4394 case "StateReasonCode": 4395 if value != nil { 4396 jtv, ok := value.(string) 4397 if !ok { 4398 return fmt.Errorf("expected StateReasonCode to be of type string, got %T instead", value) 4399 } 4400 sv.StateReasonCode = types.StateReasonCode(jtv) 4401 } 4402 4403 case "Timeout": 4404 if value != nil { 4405 jtv, ok := value.(json.Number) 4406 if !ok { 4407 return fmt.Errorf("expected Timeout to be json.Number, got %T instead", value) 4408 } 4409 i64, err := jtv.Int64() 4410 if err != nil { 4411 return err 4412 } 4413 sv.Timeout = ptr.Int32(int32(i64)) 4414 } 4415 4416 case "TracingConfig": 4417 if err := awsRestjson1_deserializeDocumentTracingConfigResponse(&sv.TracingConfig, value); err != nil { 4418 return err 4419 } 4420 4421 case "Version": 4422 if value != nil { 4423 jtv, ok := value.(string) 4424 if !ok { 4425 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 4426 } 4427 sv.Version = ptr.String(jtv) 4428 } 4429 4430 case "VpcConfig": 4431 if err := awsRestjson1_deserializeDocumentVpcConfigResponse(&sv.VpcConfig, value); err != nil { 4432 return err 4433 } 4434 4435 default: 4436 _, _ = key, value 4437 4438 } 4439 } 4440 *v = sv 4441 return nil 4442} 4443 4444type awsRestjson1_deserializeOpGetFunctionEventInvokeConfig struct { 4445} 4446 4447func (*awsRestjson1_deserializeOpGetFunctionEventInvokeConfig) ID() string { 4448 return "OperationDeserializer" 4449} 4450 4451func (m *awsRestjson1_deserializeOpGetFunctionEventInvokeConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4452 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4453) { 4454 out, metadata, err = next.HandleDeserialize(ctx, in) 4455 if err != nil { 4456 return out, metadata, err 4457 } 4458 4459 response, ok := out.RawResponse.(*smithyhttp.Response) 4460 if !ok { 4461 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4462 } 4463 4464 if response.StatusCode < 200 || response.StatusCode >= 300 { 4465 return out, metadata, awsRestjson1_deserializeOpErrorGetFunctionEventInvokeConfig(response, &metadata) 4466 } 4467 output := &GetFunctionEventInvokeConfigOutput{} 4468 out.Result = output 4469 4470 var buff [1024]byte 4471 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4472 4473 body := io.TeeReader(response.Body, ringBuffer) 4474 4475 decoder := json.NewDecoder(body) 4476 decoder.UseNumber() 4477 var shape interface{} 4478 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4479 var snapshot bytes.Buffer 4480 io.Copy(&snapshot, ringBuffer) 4481 err = &smithy.DeserializationError{ 4482 Err: fmt.Errorf("failed to decode response body, %w", err), 4483 Snapshot: snapshot.Bytes(), 4484 } 4485 return out, metadata, err 4486 } 4487 4488 err = awsRestjson1_deserializeOpDocumentGetFunctionEventInvokeConfigOutput(&output, shape) 4489 if err != nil { 4490 var snapshot bytes.Buffer 4491 io.Copy(&snapshot, ringBuffer) 4492 return out, metadata, &smithy.DeserializationError{ 4493 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4494 Snapshot: snapshot.Bytes(), 4495 } 4496 } 4497 4498 return out, metadata, err 4499} 4500 4501func awsRestjson1_deserializeOpErrorGetFunctionEventInvokeConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4502 var errorBuffer bytes.Buffer 4503 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4504 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4505 } 4506 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4507 4508 errorCode := "UnknownError" 4509 errorMessage := errorCode 4510 4511 code := response.Header.Get("X-Amzn-ErrorType") 4512 if len(code) != 0 { 4513 errorCode = restjson.SanitizeErrorCode(code) 4514 } 4515 4516 var buff [1024]byte 4517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4518 4519 body := io.TeeReader(errorBody, ringBuffer) 4520 decoder := json.NewDecoder(body) 4521 decoder.UseNumber() 4522 code, message, err := restjson.GetErrorInfo(decoder) 4523 if err != nil { 4524 var snapshot bytes.Buffer 4525 io.Copy(&snapshot, ringBuffer) 4526 err = &smithy.DeserializationError{ 4527 Err: fmt.Errorf("failed to decode response body, %w", err), 4528 Snapshot: snapshot.Bytes(), 4529 } 4530 return err 4531 } 4532 4533 errorBody.Seek(0, io.SeekStart) 4534 if len(code) != 0 { 4535 errorCode = restjson.SanitizeErrorCode(code) 4536 } 4537 if len(message) != 0 { 4538 errorMessage = message 4539 } 4540 4541 switch { 4542 case strings.EqualFold("InvalidParameterValueException", errorCode): 4543 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 4544 4545 case strings.EqualFold("ResourceNotFoundException", errorCode): 4546 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4547 4548 case strings.EqualFold("ServiceException", errorCode): 4549 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 4550 4551 case strings.EqualFold("TooManyRequestsException", errorCode): 4552 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4553 4554 default: 4555 genericError := &smithy.GenericAPIError{ 4556 Code: errorCode, 4557 Message: errorMessage, 4558 } 4559 return genericError 4560 4561 } 4562} 4563 4564func awsRestjson1_deserializeOpDocumentGetFunctionEventInvokeConfigOutput(v **GetFunctionEventInvokeConfigOutput, value interface{}) error { 4565 if v == nil { 4566 return fmt.Errorf("unexpected nil of type %T", v) 4567 } 4568 if value == nil { 4569 return nil 4570 } 4571 4572 shape, ok := value.(map[string]interface{}) 4573 if !ok { 4574 return fmt.Errorf("unexpected JSON type %v", value) 4575 } 4576 4577 var sv *GetFunctionEventInvokeConfigOutput 4578 if *v == nil { 4579 sv = &GetFunctionEventInvokeConfigOutput{} 4580 } else { 4581 sv = *v 4582 } 4583 4584 for key, value := range shape { 4585 switch key { 4586 case "DestinationConfig": 4587 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 4588 return err 4589 } 4590 4591 case "FunctionArn": 4592 if value != nil { 4593 jtv, ok := value.(string) 4594 if !ok { 4595 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 4596 } 4597 sv.FunctionArn = ptr.String(jtv) 4598 } 4599 4600 case "LastModified": 4601 if value != nil { 4602 jtv, ok := value.(json.Number) 4603 if !ok { 4604 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 4605 } 4606 f64, err := jtv.Float64() 4607 if err != nil { 4608 return err 4609 } 4610 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4611 } 4612 4613 case "MaximumEventAgeInSeconds": 4614 if value != nil { 4615 jtv, ok := value.(json.Number) 4616 if !ok { 4617 return fmt.Errorf("expected MaximumEventAgeInSeconds to be json.Number, got %T instead", value) 4618 } 4619 i64, err := jtv.Int64() 4620 if err != nil { 4621 return err 4622 } 4623 sv.MaximumEventAgeInSeconds = ptr.Int32(int32(i64)) 4624 } 4625 4626 case "MaximumRetryAttempts": 4627 if value != nil { 4628 jtv, ok := value.(json.Number) 4629 if !ok { 4630 return fmt.Errorf("expected MaximumRetryAttempts to be json.Number, got %T instead", value) 4631 } 4632 i64, err := jtv.Int64() 4633 if err != nil { 4634 return err 4635 } 4636 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 4637 } 4638 4639 default: 4640 _, _ = key, value 4641 4642 } 4643 } 4644 *v = sv 4645 return nil 4646} 4647 4648type awsRestjson1_deserializeOpGetLayerVersion struct { 4649} 4650 4651func (*awsRestjson1_deserializeOpGetLayerVersion) ID() string { 4652 return "OperationDeserializer" 4653} 4654 4655func (m *awsRestjson1_deserializeOpGetLayerVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4656 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4657) { 4658 out, metadata, err = next.HandleDeserialize(ctx, in) 4659 if err != nil { 4660 return out, metadata, err 4661 } 4662 4663 response, ok := out.RawResponse.(*smithyhttp.Response) 4664 if !ok { 4665 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4666 } 4667 4668 if response.StatusCode < 200 || response.StatusCode >= 300 { 4669 return out, metadata, awsRestjson1_deserializeOpErrorGetLayerVersion(response, &metadata) 4670 } 4671 output := &GetLayerVersionOutput{} 4672 out.Result = output 4673 4674 var buff [1024]byte 4675 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4676 4677 body := io.TeeReader(response.Body, ringBuffer) 4678 4679 decoder := json.NewDecoder(body) 4680 decoder.UseNumber() 4681 var shape interface{} 4682 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4683 var snapshot bytes.Buffer 4684 io.Copy(&snapshot, ringBuffer) 4685 err = &smithy.DeserializationError{ 4686 Err: fmt.Errorf("failed to decode response body, %w", err), 4687 Snapshot: snapshot.Bytes(), 4688 } 4689 return out, metadata, err 4690 } 4691 4692 err = awsRestjson1_deserializeOpDocumentGetLayerVersionOutput(&output, shape) 4693 if err != nil { 4694 var snapshot bytes.Buffer 4695 io.Copy(&snapshot, ringBuffer) 4696 return out, metadata, &smithy.DeserializationError{ 4697 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4698 Snapshot: snapshot.Bytes(), 4699 } 4700 } 4701 4702 return out, metadata, err 4703} 4704 4705func awsRestjson1_deserializeOpErrorGetLayerVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4706 var errorBuffer bytes.Buffer 4707 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4708 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4709 } 4710 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4711 4712 errorCode := "UnknownError" 4713 errorMessage := errorCode 4714 4715 code := response.Header.Get("X-Amzn-ErrorType") 4716 if len(code) != 0 { 4717 errorCode = restjson.SanitizeErrorCode(code) 4718 } 4719 4720 var buff [1024]byte 4721 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4722 4723 body := io.TeeReader(errorBody, ringBuffer) 4724 decoder := json.NewDecoder(body) 4725 decoder.UseNumber() 4726 code, message, err := restjson.GetErrorInfo(decoder) 4727 if err != nil { 4728 var snapshot bytes.Buffer 4729 io.Copy(&snapshot, ringBuffer) 4730 err = &smithy.DeserializationError{ 4731 Err: fmt.Errorf("failed to decode response body, %w", err), 4732 Snapshot: snapshot.Bytes(), 4733 } 4734 return err 4735 } 4736 4737 errorBody.Seek(0, io.SeekStart) 4738 if len(code) != 0 { 4739 errorCode = restjson.SanitizeErrorCode(code) 4740 } 4741 if len(message) != 0 { 4742 errorMessage = message 4743 } 4744 4745 switch { 4746 case strings.EqualFold("InvalidParameterValueException", errorCode): 4747 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 4748 4749 case strings.EqualFold("ResourceNotFoundException", errorCode): 4750 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4751 4752 case strings.EqualFold("ServiceException", errorCode): 4753 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 4754 4755 case strings.EqualFold("TooManyRequestsException", errorCode): 4756 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4757 4758 default: 4759 genericError := &smithy.GenericAPIError{ 4760 Code: errorCode, 4761 Message: errorMessage, 4762 } 4763 return genericError 4764 4765 } 4766} 4767 4768func awsRestjson1_deserializeOpDocumentGetLayerVersionOutput(v **GetLayerVersionOutput, value interface{}) error { 4769 if v == nil { 4770 return fmt.Errorf("unexpected nil of type %T", v) 4771 } 4772 if value == nil { 4773 return nil 4774 } 4775 4776 shape, ok := value.(map[string]interface{}) 4777 if !ok { 4778 return fmt.Errorf("unexpected JSON type %v", value) 4779 } 4780 4781 var sv *GetLayerVersionOutput 4782 if *v == nil { 4783 sv = &GetLayerVersionOutput{} 4784 } else { 4785 sv = *v 4786 } 4787 4788 for key, value := range shape { 4789 switch key { 4790 case "CompatibleRuntimes": 4791 if err := awsRestjson1_deserializeDocumentCompatibleRuntimes(&sv.CompatibleRuntimes, value); err != nil { 4792 return err 4793 } 4794 4795 case "Content": 4796 if err := awsRestjson1_deserializeDocumentLayerVersionContentOutput(&sv.Content, value); err != nil { 4797 return err 4798 } 4799 4800 case "CreatedDate": 4801 if value != nil { 4802 jtv, ok := value.(string) 4803 if !ok { 4804 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 4805 } 4806 sv.CreatedDate = ptr.String(jtv) 4807 } 4808 4809 case "Description": 4810 if value != nil { 4811 jtv, ok := value.(string) 4812 if !ok { 4813 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 4814 } 4815 sv.Description = ptr.String(jtv) 4816 } 4817 4818 case "LayerArn": 4819 if value != nil { 4820 jtv, ok := value.(string) 4821 if !ok { 4822 return fmt.Errorf("expected LayerArn to be of type string, got %T instead", value) 4823 } 4824 sv.LayerArn = ptr.String(jtv) 4825 } 4826 4827 case "LayerVersionArn": 4828 if value != nil { 4829 jtv, ok := value.(string) 4830 if !ok { 4831 return fmt.Errorf("expected LayerVersionArn to be of type string, got %T instead", value) 4832 } 4833 sv.LayerVersionArn = ptr.String(jtv) 4834 } 4835 4836 case "LicenseInfo": 4837 if value != nil { 4838 jtv, ok := value.(string) 4839 if !ok { 4840 return fmt.Errorf("expected LicenseInfo to be of type string, got %T instead", value) 4841 } 4842 sv.LicenseInfo = ptr.String(jtv) 4843 } 4844 4845 case "Version": 4846 if value != nil { 4847 jtv, ok := value.(json.Number) 4848 if !ok { 4849 return fmt.Errorf("expected LayerVersionNumber to be json.Number, got %T instead", value) 4850 } 4851 i64, err := jtv.Int64() 4852 if err != nil { 4853 return err 4854 } 4855 sv.Version = i64 4856 } 4857 4858 default: 4859 _, _ = key, value 4860 4861 } 4862 } 4863 *v = sv 4864 return nil 4865} 4866 4867type awsRestjson1_deserializeOpGetLayerVersionByArn struct { 4868} 4869 4870func (*awsRestjson1_deserializeOpGetLayerVersionByArn) ID() string { 4871 return "OperationDeserializer" 4872} 4873 4874func (m *awsRestjson1_deserializeOpGetLayerVersionByArn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4875 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4876) { 4877 out, metadata, err = next.HandleDeserialize(ctx, in) 4878 if err != nil { 4879 return out, metadata, err 4880 } 4881 4882 response, ok := out.RawResponse.(*smithyhttp.Response) 4883 if !ok { 4884 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4885 } 4886 4887 if response.StatusCode < 200 || response.StatusCode >= 300 { 4888 return out, metadata, awsRestjson1_deserializeOpErrorGetLayerVersionByArn(response, &metadata) 4889 } 4890 output := &GetLayerVersionByArnOutput{} 4891 out.Result = output 4892 4893 var buff [1024]byte 4894 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4895 4896 body := io.TeeReader(response.Body, ringBuffer) 4897 4898 decoder := json.NewDecoder(body) 4899 decoder.UseNumber() 4900 var shape interface{} 4901 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4902 var snapshot bytes.Buffer 4903 io.Copy(&snapshot, ringBuffer) 4904 err = &smithy.DeserializationError{ 4905 Err: fmt.Errorf("failed to decode response body, %w", err), 4906 Snapshot: snapshot.Bytes(), 4907 } 4908 return out, metadata, err 4909 } 4910 4911 err = awsRestjson1_deserializeOpDocumentGetLayerVersionByArnOutput(&output, shape) 4912 if err != nil { 4913 var snapshot bytes.Buffer 4914 io.Copy(&snapshot, ringBuffer) 4915 return out, metadata, &smithy.DeserializationError{ 4916 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4917 Snapshot: snapshot.Bytes(), 4918 } 4919 } 4920 4921 return out, metadata, err 4922} 4923 4924func awsRestjson1_deserializeOpErrorGetLayerVersionByArn(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4925 var errorBuffer bytes.Buffer 4926 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4927 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4928 } 4929 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4930 4931 errorCode := "UnknownError" 4932 errorMessage := errorCode 4933 4934 code := response.Header.Get("X-Amzn-ErrorType") 4935 if len(code) != 0 { 4936 errorCode = restjson.SanitizeErrorCode(code) 4937 } 4938 4939 var buff [1024]byte 4940 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4941 4942 body := io.TeeReader(errorBody, ringBuffer) 4943 decoder := json.NewDecoder(body) 4944 decoder.UseNumber() 4945 code, message, err := restjson.GetErrorInfo(decoder) 4946 if err != nil { 4947 var snapshot bytes.Buffer 4948 io.Copy(&snapshot, ringBuffer) 4949 err = &smithy.DeserializationError{ 4950 Err: fmt.Errorf("failed to decode response body, %w", err), 4951 Snapshot: snapshot.Bytes(), 4952 } 4953 return err 4954 } 4955 4956 errorBody.Seek(0, io.SeekStart) 4957 if len(code) != 0 { 4958 errorCode = restjson.SanitizeErrorCode(code) 4959 } 4960 if len(message) != 0 { 4961 errorMessage = message 4962 } 4963 4964 switch { 4965 case strings.EqualFold("InvalidParameterValueException", errorCode): 4966 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 4967 4968 case strings.EqualFold("ResourceNotFoundException", errorCode): 4969 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4970 4971 case strings.EqualFold("ServiceException", errorCode): 4972 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 4973 4974 case strings.EqualFold("TooManyRequestsException", errorCode): 4975 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4976 4977 default: 4978 genericError := &smithy.GenericAPIError{ 4979 Code: errorCode, 4980 Message: errorMessage, 4981 } 4982 return genericError 4983 4984 } 4985} 4986 4987func awsRestjson1_deserializeOpDocumentGetLayerVersionByArnOutput(v **GetLayerVersionByArnOutput, value interface{}) error { 4988 if v == nil { 4989 return fmt.Errorf("unexpected nil of type %T", v) 4990 } 4991 if value == nil { 4992 return nil 4993 } 4994 4995 shape, ok := value.(map[string]interface{}) 4996 if !ok { 4997 return fmt.Errorf("unexpected JSON type %v", value) 4998 } 4999 5000 var sv *GetLayerVersionByArnOutput 5001 if *v == nil { 5002 sv = &GetLayerVersionByArnOutput{} 5003 } else { 5004 sv = *v 5005 } 5006 5007 for key, value := range shape { 5008 switch key { 5009 case "CompatibleRuntimes": 5010 if err := awsRestjson1_deserializeDocumentCompatibleRuntimes(&sv.CompatibleRuntimes, value); err != nil { 5011 return err 5012 } 5013 5014 case "Content": 5015 if err := awsRestjson1_deserializeDocumentLayerVersionContentOutput(&sv.Content, value); err != nil { 5016 return err 5017 } 5018 5019 case "CreatedDate": 5020 if value != nil { 5021 jtv, ok := value.(string) 5022 if !ok { 5023 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 5024 } 5025 sv.CreatedDate = ptr.String(jtv) 5026 } 5027 5028 case "Description": 5029 if value != nil { 5030 jtv, ok := value.(string) 5031 if !ok { 5032 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 5033 } 5034 sv.Description = ptr.String(jtv) 5035 } 5036 5037 case "LayerArn": 5038 if value != nil { 5039 jtv, ok := value.(string) 5040 if !ok { 5041 return fmt.Errorf("expected LayerArn to be of type string, got %T instead", value) 5042 } 5043 sv.LayerArn = ptr.String(jtv) 5044 } 5045 5046 case "LayerVersionArn": 5047 if value != nil { 5048 jtv, ok := value.(string) 5049 if !ok { 5050 return fmt.Errorf("expected LayerVersionArn to be of type string, got %T instead", value) 5051 } 5052 sv.LayerVersionArn = ptr.String(jtv) 5053 } 5054 5055 case "LicenseInfo": 5056 if value != nil { 5057 jtv, ok := value.(string) 5058 if !ok { 5059 return fmt.Errorf("expected LicenseInfo to be of type string, got %T instead", value) 5060 } 5061 sv.LicenseInfo = ptr.String(jtv) 5062 } 5063 5064 case "Version": 5065 if value != nil { 5066 jtv, ok := value.(json.Number) 5067 if !ok { 5068 return fmt.Errorf("expected LayerVersionNumber to be json.Number, got %T instead", value) 5069 } 5070 i64, err := jtv.Int64() 5071 if err != nil { 5072 return err 5073 } 5074 sv.Version = i64 5075 } 5076 5077 default: 5078 _, _ = key, value 5079 5080 } 5081 } 5082 *v = sv 5083 return nil 5084} 5085 5086type awsRestjson1_deserializeOpGetLayerVersionPolicy struct { 5087} 5088 5089func (*awsRestjson1_deserializeOpGetLayerVersionPolicy) ID() string { 5090 return "OperationDeserializer" 5091} 5092 5093func (m *awsRestjson1_deserializeOpGetLayerVersionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5094 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5095) { 5096 out, metadata, err = next.HandleDeserialize(ctx, in) 5097 if err != nil { 5098 return out, metadata, err 5099 } 5100 5101 response, ok := out.RawResponse.(*smithyhttp.Response) 5102 if !ok { 5103 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5104 } 5105 5106 if response.StatusCode < 200 || response.StatusCode >= 300 { 5107 return out, metadata, awsRestjson1_deserializeOpErrorGetLayerVersionPolicy(response, &metadata) 5108 } 5109 output := &GetLayerVersionPolicyOutput{} 5110 out.Result = output 5111 5112 var buff [1024]byte 5113 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5114 5115 body := io.TeeReader(response.Body, ringBuffer) 5116 5117 decoder := json.NewDecoder(body) 5118 decoder.UseNumber() 5119 var shape interface{} 5120 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5121 var snapshot bytes.Buffer 5122 io.Copy(&snapshot, ringBuffer) 5123 err = &smithy.DeserializationError{ 5124 Err: fmt.Errorf("failed to decode response body, %w", err), 5125 Snapshot: snapshot.Bytes(), 5126 } 5127 return out, metadata, err 5128 } 5129 5130 err = awsRestjson1_deserializeOpDocumentGetLayerVersionPolicyOutput(&output, shape) 5131 if err != nil { 5132 var snapshot bytes.Buffer 5133 io.Copy(&snapshot, ringBuffer) 5134 return out, metadata, &smithy.DeserializationError{ 5135 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5136 Snapshot: snapshot.Bytes(), 5137 } 5138 } 5139 5140 return out, metadata, err 5141} 5142 5143func awsRestjson1_deserializeOpErrorGetLayerVersionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5144 var errorBuffer bytes.Buffer 5145 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5146 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5147 } 5148 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5149 5150 errorCode := "UnknownError" 5151 errorMessage := errorCode 5152 5153 code := response.Header.Get("X-Amzn-ErrorType") 5154 if len(code) != 0 { 5155 errorCode = restjson.SanitizeErrorCode(code) 5156 } 5157 5158 var buff [1024]byte 5159 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5160 5161 body := io.TeeReader(errorBody, ringBuffer) 5162 decoder := json.NewDecoder(body) 5163 decoder.UseNumber() 5164 code, message, err := restjson.GetErrorInfo(decoder) 5165 if err != nil { 5166 var snapshot bytes.Buffer 5167 io.Copy(&snapshot, ringBuffer) 5168 err = &smithy.DeserializationError{ 5169 Err: fmt.Errorf("failed to decode response body, %w", err), 5170 Snapshot: snapshot.Bytes(), 5171 } 5172 return err 5173 } 5174 5175 errorBody.Seek(0, io.SeekStart) 5176 if len(code) != 0 { 5177 errorCode = restjson.SanitizeErrorCode(code) 5178 } 5179 if len(message) != 0 { 5180 errorMessage = message 5181 } 5182 5183 switch { 5184 case strings.EqualFold("InvalidParameterValueException", errorCode): 5185 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 5186 5187 case strings.EqualFold("ResourceNotFoundException", errorCode): 5188 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5189 5190 case strings.EqualFold("ServiceException", errorCode): 5191 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 5192 5193 case strings.EqualFold("TooManyRequestsException", errorCode): 5194 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5195 5196 default: 5197 genericError := &smithy.GenericAPIError{ 5198 Code: errorCode, 5199 Message: errorMessage, 5200 } 5201 return genericError 5202 5203 } 5204} 5205 5206func awsRestjson1_deserializeOpDocumentGetLayerVersionPolicyOutput(v **GetLayerVersionPolicyOutput, value interface{}) error { 5207 if v == nil { 5208 return fmt.Errorf("unexpected nil of type %T", v) 5209 } 5210 if value == nil { 5211 return nil 5212 } 5213 5214 shape, ok := value.(map[string]interface{}) 5215 if !ok { 5216 return fmt.Errorf("unexpected JSON type %v", value) 5217 } 5218 5219 var sv *GetLayerVersionPolicyOutput 5220 if *v == nil { 5221 sv = &GetLayerVersionPolicyOutput{} 5222 } else { 5223 sv = *v 5224 } 5225 5226 for key, value := range shape { 5227 switch key { 5228 case "Policy": 5229 if value != nil { 5230 jtv, ok := value.(string) 5231 if !ok { 5232 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5233 } 5234 sv.Policy = ptr.String(jtv) 5235 } 5236 5237 case "RevisionId": 5238 if value != nil { 5239 jtv, ok := value.(string) 5240 if !ok { 5241 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5242 } 5243 sv.RevisionId = ptr.String(jtv) 5244 } 5245 5246 default: 5247 _, _ = key, value 5248 5249 } 5250 } 5251 *v = sv 5252 return nil 5253} 5254 5255type awsRestjson1_deserializeOpGetPolicy struct { 5256} 5257 5258func (*awsRestjson1_deserializeOpGetPolicy) ID() string { 5259 return "OperationDeserializer" 5260} 5261 5262func (m *awsRestjson1_deserializeOpGetPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5263 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5264) { 5265 out, metadata, err = next.HandleDeserialize(ctx, in) 5266 if err != nil { 5267 return out, metadata, err 5268 } 5269 5270 response, ok := out.RawResponse.(*smithyhttp.Response) 5271 if !ok { 5272 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5273 } 5274 5275 if response.StatusCode < 200 || response.StatusCode >= 300 { 5276 return out, metadata, awsRestjson1_deserializeOpErrorGetPolicy(response, &metadata) 5277 } 5278 output := &GetPolicyOutput{} 5279 out.Result = output 5280 5281 var buff [1024]byte 5282 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5283 5284 body := io.TeeReader(response.Body, ringBuffer) 5285 5286 decoder := json.NewDecoder(body) 5287 decoder.UseNumber() 5288 var shape interface{} 5289 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5290 var snapshot bytes.Buffer 5291 io.Copy(&snapshot, ringBuffer) 5292 err = &smithy.DeserializationError{ 5293 Err: fmt.Errorf("failed to decode response body, %w", err), 5294 Snapshot: snapshot.Bytes(), 5295 } 5296 return out, metadata, err 5297 } 5298 5299 err = awsRestjson1_deserializeOpDocumentGetPolicyOutput(&output, shape) 5300 if err != nil { 5301 var snapshot bytes.Buffer 5302 io.Copy(&snapshot, ringBuffer) 5303 return out, metadata, &smithy.DeserializationError{ 5304 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5305 Snapshot: snapshot.Bytes(), 5306 } 5307 } 5308 5309 return out, metadata, err 5310} 5311 5312func awsRestjson1_deserializeOpErrorGetPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5313 var errorBuffer bytes.Buffer 5314 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5315 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5316 } 5317 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5318 5319 errorCode := "UnknownError" 5320 errorMessage := errorCode 5321 5322 code := response.Header.Get("X-Amzn-ErrorType") 5323 if len(code) != 0 { 5324 errorCode = restjson.SanitizeErrorCode(code) 5325 } 5326 5327 var buff [1024]byte 5328 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5329 5330 body := io.TeeReader(errorBody, ringBuffer) 5331 decoder := json.NewDecoder(body) 5332 decoder.UseNumber() 5333 code, message, err := restjson.GetErrorInfo(decoder) 5334 if err != nil { 5335 var snapshot bytes.Buffer 5336 io.Copy(&snapshot, ringBuffer) 5337 err = &smithy.DeserializationError{ 5338 Err: fmt.Errorf("failed to decode response body, %w", err), 5339 Snapshot: snapshot.Bytes(), 5340 } 5341 return err 5342 } 5343 5344 errorBody.Seek(0, io.SeekStart) 5345 if len(code) != 0 { 5346 errorCode = restjson.SanitizeErrorCode(code) 5347 } 5348 if len(message) != 0 { 5349 errorMessage = message 5350 } 5351 5352 switch { 5353 case strings.EqualFold("InvalidParameterValueException", errorCode): 5354 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 5355 5356 case strings.EqualFold("ResourceNotFoundException", errorCode): 5357 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5358 5359 case strings.EqualFold("ServiceException", errorCode): 5360 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 5361 5362 case strings.EqualFold("TooManyRequestsException", errorCode): 5363 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5364 5365 default: 5366 genericError := &smithy.GenericAPIError{ 5367 Code: errorCode, 5368 Message: errorMessage, 5369 } 5370 return genericError 5371 5372 } 5373} 5374 5375func awsRestjson1_deserializeOpDocumentGetPolicyOutput(v **GetPolicyOutput, value interface{}) error { 5376 if v == nil { 5377 return fmt.Errorf("unexpected nil of type %T", v) 5378 } 5379 if value == nil { 5380 return nil 5381 } 5382 5383 shape, ok := value.(map[string]interface{}) 5384 if !ok { 5385 return fmt.Errorf("unexpected JSON type %v", value) 5386 } 5387 5388 var sv *GetPolicyOutput 5389 if *v == nil { 5390 sv = &GetPolicyOutput{} 5391 } else { 5392 sv = *v 5393 } 5394 5395 for key, value := range shape { 5396 switch key { 5397 case "Policy": 5398 if value != nil { 5399 jtv, ok := value.(string) 5400 if !ok { 5401 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5402 } 5403 sv.Policy = ptr.String(jtv) 5404 } 5405 5406 case "RevisionId": 5407 if value != nil { 5408 jtv, ok := value.(string) 5409 if !ok { 5410 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5411 } 5412 sv.RevisionId = ptr.String(jtv) 5413 } 5414 5415 default: 5416 _, _ = key, value 5417 5418 } 5419 } 5420 *v = sv 5421 return nil 5422} 5423 5424type awsRestjson1_deserializeOpGetProvisionedConcurrencyConfig struct { 5425} 5426 5427func (*awsRestjson1_deserializeOpGetProvisionedConcurrencyConfig) ID() string { 5428 return "OperationDeserializer" 5429} 5430 5431func (m *awsRestjson1_deserializeOpGetProvisionedConcurrencyConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5432 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5433) { 5434 out, metadata, err = next.HandleDeserialize(ctx, in) 5435 if err != nil { 5436 return out, metadata, err 5437 } 5438 5439 response, ok := out.RawResponse.(*smithyhttp.Response) 5440 if !ok { 5441 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5442 } 5443 5444 if response.StatusCode < 200 || response.StatusCode >= 300 { 5445 return out, metadata, awsRestjson1_deserializeOpErrorGetProvisionedConcurrencyConfig(response, &metadata) 5446 } 5447 output := &GetProvisionedConcurrencyConfigOutput{} 5448 out.Result = output 5449 5450 var buff [1024]byte 5451 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5452 5453 body := io.TeeReader(response.Body, ringBuffer) 5454 5455 decoder := json.NewDecoder(body) 5456 decoder.UseNumber() 5457 var shape interface{} 5458 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5459 var snapshot bytes.Buffer 5460 io.Copy(&snapshot, ringBuffer) 5461 err = &smithy.DeserializationError{ 5462 Err: fmt.Errorf("failed to decode response body, %w", err), 5463 Snapshot: snapshot.Bytes(), 5464 } 5465 return out, metadata, err 5466 } 5467 5468 err = awsRestjson1_deserializeOpDocumentGetProvisionedConcurrencyConfigOutput(&output, shape) 5469 if err != nil { 5470 var snapshot bytes.Buffer 5471 io.Copy(&snapshot, ringBuffer) 5472 return out, metadata, &smithy.DeserializationError{ 5473 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5474 Snapshot: snapshot.Bytes(), 5475 } 5476 } 5477 5478 return out, metadata, err 5479} 5480 5481func awsRestjson1_deserializeOpErrorGetProvisionedConcurrencyConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5482 var errorBuffer bytes.Buffer 5483 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5484 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5485 } 5486 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5487 5488 errorCode := "UnknownError" 5489 errorMessage := errorCode 5490 5491 code := response.Header.Get("X-Amzn-ErrorType") 5492 if len(code) != 0 { 5493 errorCode = restjson.SanitizeErrorCode(code) 5494 } 5495 5496 var buff [1024]byte 5497 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5498 5499 body := io.TeeReader(errorBody, ringBuffer) 5500 decoder := json.NewDecoder(body) 5501 decoder.UseNumber() 5502 code, message, err := restjson.GetErrorInfo(decoder) 5503 if err != nil { 5504 var snapshot bytes.Buffer 5505 io.Copy(&snapshot, ringBuffer) 5506 err = &smithy.DeserializationError{ 5507 Err: fmt.Errorf("failed to decode response body, %w", err), 5508 Snapshot: snapshot.Bytes(), 5509 } 5510 return err 5511 } 5512 5513 errorBody.Seek(0, io.SeekStart) 5514 if len(code) != 0 { 5515 errorCode = restjson.SanitizeErrorCode(code) 5516 } 5517 if len(message) != 0 { 5518 errorMessage = message 5519 } 5520 5521 switch { 5522 case strings.EqualFold("InvalidParameterValueException", errorCode): 5523 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 5524 5525 case strings.EqualFold("ProvisionedConcurrencyConfigNotFoundException", errorCode): 5526 return awsRestjson1_deserializeErrorProvisionedConcurrencyConfigNotFoundException(response, errorBody) 5527 5528 case strings.EqualFold("ResourceNotFoundException", errorCode): 5529 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5530 5531 case strings.EqualFold("ServiceException", errorCode): 5532 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 5533 5534 case strings.EqualFold("TooManyRequestsException", errorCode): 5535 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5536 5537 default: 5538 genericError := &smithy.GenericAPIError{ 5539 Code: errorCode, 5540 Message: errorMessage, 5541 } 5542 return genericError 5543 5544 } 5545} 5546 5547func awsRestjson1_deserializeOpDocumentGetProvisionedConcurrencyConfigOutput(v **GetProvisionedConcurrencyConfigOutput, value interface{}) error { 5548 if v == nil { 5549 return fmt.Errorf("unexpected nil of type %T", v) 5550 } 5551 if value == nil { 5552 return nil 5553 } 5554 5555 shape, ok := value.(map[string]interface{}) 5556 if !ok { 5557 return fmt.Errorf("unexpected JSON type %v", value) 5558 } 5559 5560 var sv *GetProvisionedConcurrencyConfigOutput 5561 if *v == nil { 5562 sv = &GetProvisionedConcurrencyConfigOutput{} 5563 } else { 5564 sv = *v 5565 } 5566 5567 for key, value := range shape { 5568 switch key { 5569 case "AllocatedProvisionedConcurrentExecutions": 5570 if value != nil { 5571 jtv, ok := value.(json.Number) 5572 if !ok { 5573 return fmt.Errorf("expected NonNegativeInteger to be json.Number, got %T instead", value) 5574 } 5575 i64, err := jtv.Int64() 5576 if err != nil { 5577 return err 5578 } 5579 sv.AllocatedProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 5580 } 5581 5582 case "AvailableProvisionedConcurrentExecutions": 5583 if value != nil { 5584 jtv, ok := value.(json.Number) 5585 if !ok { 5586 return fmt.Errorf("expected NonNegativeInteger to be json.Number, got %T instead", value) 5587 } 5588 i64, err := jtv.Int64() 5589 if err != nil { 5590 return err 5591 } 5592 sv.AvailableProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 5593 } 5594 5595 case "LastModified": 5596 if value != nil { 5597 jtv, ok := value.(string) 5598 if !ok { 5599 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 5600 } 5601 sv.LastModified = ptr.String(jtv) 5602 } 5603 5604 case "RequestedProvisionedConcurrentExecutions": 5605 if value != nil { 5606 jtv, ok := value.(json.Number) 5607 if !ok { 5608 return fmt.Errorf("expected PositiveInteger to be json.Number, got %T instead", value) 5609 } 5610 i64, err := jtv.Int64() 5611 if err != nil { 5612 return err 5613 } 5614 sv.RequestedProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 5615 } 5616 5617 case "Status": 5618 if value != nil { 5619 jtv, ok := value.(string) 5620 if !ok { 5621 return fmt.Errorf("expected ProvisionedConcurrencyStatusEnum to be of type string, got %T instead", value) 5622 } 5623 sv.Status = types.ProvisionedConcurrencyStatusEnum(jtv) 5624 } 5625 5626 case "StatusReason": 5627 if value != nil { 5628 jtv, ok := value.(string) 5629 if !ok { 5630 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5631 } 5632 sv.StatusReason = ptr.String(jtv) 5633 } 5634 5635 default: 5636 _, _ = key, value 5637 5638 } 5639 } 5640 *v = sv 5641 return nil 5642} 5643 5644type awsRestjson1_deserializeOpInvoke struct { 5645} 5646 5647func (*awsRestjson1_deserializeOpInvoke) ID() string { 5648 return "OperationDeserializer" 5649} 5650 5651func (m *awsRestjson1_deserializeOpInvoke) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5652 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5653) { 5654 out, metadata, err = next.HandleDeserialize(ctx, in) 5655 if err != nil { 5656 return out, metadata, err 5657 } 5658 5659 response, ok := out.RawResponse.(*smithyhttp.Response) 5660 if !ok { 5661 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5662 } 5663 5664 if response.StatusCode < 200 || response.StatusCode >= 300 { 5665 return out, metadata, awsRestjson1_deserializeOpErrorInvoke(response, &metadata) 5666 } 5667 output := &InvokeOutput{} 5668 out.Result = output 5669 5670 err = awsRestjson1_deserializeOpHttpBindingsInvokeOutput(output, response) 5671 if err != nil { 5672 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 5673 } 5674 5675 err = awsRestjson1_deserializeOpDocumentInvokeOutput(output, response.Body) 5676 if err != nil { 5677 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 5678 } 5679 5680 return out, metadata, err 5681} 5682 5683func awsRestjson1_deserializeOpErrorInvoke(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5684 var errorBuffer bytes.Buffer 5685 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5686 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5687 } 5688 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5689 5690 errorCode := "UnknownError" 5691 errorMessage := errorCode 5692 5693 code := response.Header.Get("X-Amzn-ErrorType") 5694 if len(code) != 0 { 5695 errorCode = restjson.SanitizeErrorCode(code) 5696 } 5697 5698 var buff [1024]byte 5699 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5700 5701 body := io.TeeReader(errorBody, ringBuffer) 5702 decoder := json.NewDecoder(body) 5703 decoder.UseNumber() 5704 code, message, err := restjson.GetErrorInfo(decoder) 5705 if err != nil { 5706 var snapshot bytes.Buffer 5707 io.Copy(&snapshot, ringBuffer) 5708 err = &smithy.DeserializationError{ 5709 Err: fmt.Errorf("failed to decode response body, %w", err), 5710 Snapshot: snapshot.Bytes(), 5711 } 5712 return err 5713 } 5714 5715 errorBody.Seek(0, io.SeekStart) 5716 if len(code) != 0 { 5717 errorCode = restjson.SanitizeErrorCode(code) 5718 } 5719 if len(message) != 0 { 5720 errorMessage = message 5721 } 5722 5723 switch { 5724 case strings.EqualFold("EC2AccessDeniedException", errorCode): 5725 return awsRestjson1_deserializeErrorEC2AccessDeniedException(response, errorBody) 5726 5727 case strings.EqualFold("EC2ThrottledException", errorCode): 5728 return awsRestjson1_deserializeErrorEC2ThrottledException(response, errorBody) 5729 5730 case strings.EqualFold("EC2UnexpectedException", errorCode): 5731 return awsRestjson1_deserializeErrorEC2UnexpectedException(response, errorBody) 5732 5733 case strings.EqualFold("EFSIOException", errorCode): 5734 return awsRestjson1_deserializeErrorEFSIOException(response, errorBody) 5735 5736 case strings.EqualFold("EFSMountConnectivityException", errorCode): 5737 return awsRestjson1_deserializeErrorEFSMountConnectivityException(response, errorBody) 5738 5739 case strings.EqualFold("EFSMountFailureException", errorCode): 5740 return awsRestjson1_deserializeErrorEFSMountFailureException(response, errorBody) 5741 5742 case strings.EqualFold("EFSMountTimeoutException", errorCode): 5743 return awsRestjson1_deserializeErrorEFSMountTimeoutException(response, errorBody) 5744 5745 case strings.EqualFold("ENILimitReachedException", errorCode): 5746 return awsRestjson1_deserializeErrorENILimitReachedException(response, errorBody) 5747 5748 case strings.EqualFold("InvalidParameterValueException", errorCode): 5749 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 5750 5751 case strings.EqualFold("InvalidRequestContentException", errorCode): 5752 return awsRestjson1_deserializeErrorInvalidRequestContentException(response, errorBody) 5753 5754 case strings.EqualFold("InvalidRuntimeException", errorCode): 5755 return awsRestjson1_deserializeErrorInvalidRuntimeException(response, errorBody) 5756 5757 case strings.EqualFold("InvalidSecurityGroupIDException", errorCode): 5758 return awsRestjson1_deserializeErrorInvalidSecurityGroupIDException(response, errorBody) 5759 5760 case strings.EqualFold("InvalidSubnetIDException", errorCode): 5761 return awsRestjson1_deserializeErrorInvalidSubnetIDException(response, errorBody) 5762 5763 case strings.EqualFold("InvalidZipFileException", errorCode): 5764 return awsRestjson1_deserializeErrorInvalidZipFileException(response, errorBody) 5765 5766 case strings.EqualFold("KMSAccessDeniedException", errorCode): 5767 return awsRestjson1_deserializeErrorKMSAccessDeniedException(response, errorBody) 5768 5769 case strings.EqualFold("KMSDisabledException", errorCode): 5770 return awsRestjson1_deserializeErrorKMSDisabledException(response, errorBody) 5771 5772 case strings.EqualFold("KMSInvalidStateException", errorCode): 5773 return awsRestjson1_deserializeErrorKMSInvalidStateException(response, errorBody) 5774 5775 case strings.EqualFold("KMSNotFoundException", errorCode): 5776 return awsRestjson1_deserializeErrorKMSNotFoundException(response, errorBody) 5777 5778 case strings.EqualFold("RequestTooLargeException", errorCode): 5779 return awsRestjson1_deserializeErrorRequestTooLargeException(response, errorBody) 5780 5781 case strings.EqualFold("ResourceConflictException", errorCode): 5782 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 5783 5784 case strings.EqualFold("ResourceNotFoundException", errorCode): 5785 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5786 5787 case strings.EqualFold("ResourceNotReadyException", errorCode): 5788 return awsRestjson1_deserializeErrorResourceNotReadyException(response, errorBody) 5789 5790 case strings.EqualFold("ServiceException", errorCode): 5791 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 5792 5793 case strings.EqualFold("SubnetIPAddressLimitReachedException", errorCode): 5794 return awsRestjson1_deserializeErrorSubnetIPAddressLimitReachedException(response, errorBody) 5795 5796 case strings.EqualFold("TooManyRequestsException", errorCode): 5797 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5798 5799 case strings.EqualFold("UnsupportedMediaTypeException", errorCode): 5800 return awsRestjson1_deserializeErrorUnsupportedMediaTypeException(response, errorBody) 5801 5802 default: 5803 genericError := &smithy.GenericAPIError{ 5804 Code: errorCode, 5805 Message: errorMessage, 5806 } 5807 return genericError 5808 5809 } 5810} 5811 5812func awsRestjson1_deserializeOpHttpBindingsInvokeOutput(v *InvokeOutput, response *smithyhttp.Response) error { 5813 if v == nil { 5814 return fmt.Errorf("unsupported deserialization for nil %T", v) 5815 } 5816 5817 if headerValues := response.Header.Values("X-Amz-Executed-Version"); len(headerValues) != 0 { 5818 headerValues[0] = strings.TrimSpace(headerValues[0]) 5819 v.ExecutedVersion = ptr.String(headerValues[0]) 5820 } 5821 5822 if headerValues := response.Header.Values("X-Amz-Function-Error"); len(headerValues) != 0 { 5823 headerValues[0] = strings.TrimSpace(headerValues[0]) 5824 v.FunctionError = ptr.String(headerValues[0]) 5825 } 5826 5827 if headerValues := response.Header.Values("X-Amz-Log-Result"); len(headerValues) != 0 { 5828 headerValues[0] = strings.TrimSpace(headerValues[0]) 5829 v.LogResult = ptr.String(headerValues[0]) 5830 } 5831 5832 v.StatusCode = int32(response.StatusCode) 5833 5834 return nil 5835} 5836func awsRestjson1_deserializeOpDocumentInvokeOutput(v *InvokeOutput, body io.ReadCloser) error { 5837 if v == nil { 5838 return fmt.Errorf("unsupported deserialization of nil %T", v) 5839 } 5840 5841 bs, err := ioutil.ReadAll(body) 5842 if err != nil { 5843 return err 5844 } 5845 if len(bs) > 0 { 5846 v.Payload = bs 5847 } 5848 return nil 5849} 5850 5851type awsRestjson1_deserializeOpInvokeAsync struct { 5852} 5853 5854func (*awsRestjson1_deserializeOpInvokeAsync) ID() string { 5855 return "OperationDeserializer" 5856} 5857 5858func (m *awsRestjson1_deserializeOpInvokeAsync) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5859 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5860) { 5861 out, metadata, err = next.HandleDeserialize(ctx, in) 5862 if err != nil { 5863 return out, metadata, err 5864 } 5865 5866 response, ok := out.RawResponse.(*smithyhttp.Response) 5867 if !ok { 5868 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5869 } 5870 5871 if response.StatusCode < 200 || response.StatusCode >= 300 { 5872 return out, metadata, awsRestjson1_deserializeOpErrorInvokeAsync(response, &metadata) 5873 } 5874 output := &InvokeAsyncOutput{} 5875 out.Result = output 5876 5877 err = awsRestjson1_deserializeOpHttpBindingsInvokeAsyncOutput(output, response) 5878 if err != nil { 5879 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 5880 } 5881 5882 return out, metadata, err 5883} 5884 5885func awsRestjson1_deserializeOpErrorInvokeAsync(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5886 var errorBuffer bytes.Buffer 5887 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5888 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5889 } 5890 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5891 5892 errorCode := "UnknownError" 5893 errorMessage := errorCode 5894 5895 code := response.Header.Get("X-Amzn-ErrorType") 5896 if len(code) != 0 { 5897 errorCode = restjson.SanitizeErrorCode(code) 5898 } 5899 5900 var buff [1024]byte 5901 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5902 5903 body := io.TeeReader(errorBody, ringBuffer) 5904 decoder := json.NewDecoder(body) 5905 decoder.UseNumber() 5906 code, message, err := restjson.GetErrorInfo(decoder) 5907 if err != nil { 5908 var snapshot bytes.Buffer 5909 io.Copy(&snapshot, ringBuffer) 5910 err = &smithy.DeserializationError{ 5911 Err: fmt.Errorf("failed to decode response body, %w", err), 5912 Snapshot: snapshot.Bytes(), 5913 } 5914 return err 5915 } 5916 5917 errorBody.Seek(0, io.SeekStart) 5918 if len(code) != 0 { 5919 errorCode = restjson.SanitizeErrorCode(code) 5920 } 5921 if len(message) != 0 { 5922 errorMessage = message 5923 } 5924 5925 switch { 5926 case strings.EqualFold("InvalidRequestContentException", errorCode): 5927 return awsRestjson1_deserializeErrorInvalidRequestContentException(response, errorBody) 5928 5929 case strings.EqualFold("InvalidRuntimeException", errorCode): 5930 return awsRestjson1_deserializeErrorInvalidRuntimeException(response, errorBody) 5931 5932 case strings.EqualFold("ResourceConflictException", errorCode): 5933 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 5934 5935 case strings.EqualFold("ResourceNotFoundException", errorCode): 5936 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5937 5938 case strings.EqualFold("ServiceException", errorCode): 5939 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 5940 5941 default: 5942 genericError := &smithy.GenericAPIError{ 5943 Code: errorCode, 5944 Message: errorMessage, 5945 } 5946 return genericError 5947 5948 } 5949} 5950 5951func awsRestjson1_deserializeOpHttpBindingsInvokeAsyncOutput(v *InvokeAsyncOutput, response *smithyhttp.Response) error { 5952 if v == nil { 5953 return fmt.Errorf("unsupported deserialization for nil %T", v) 5954 } 5955 5956 v.Status = int32(response.StatusCode) 5957 5958 return nil 5959} 5960 5961type awsRestjson1_deserializeOpListAliases struct { 5962} 5963 5964func (*awsRestjson1_deserializeOpListAliases) ID() string { 5965 return "OperationDeserializer" 5966} 5967 5968func (m *awsRestjson1_deserializeOpListAliases) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5969 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5970) { 5971 out, metadata, err = next.HandleDeserialize(ctx, in) 5972 if err != nil { 5973 return out, metadata, err 5974 } 5975 5976 response, ok := out.RawResponse.(*smithyhttp.Response) 5977 if !ok { 5978 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5979 } 5980 5981 if response.StatusCode < 200 || response.StatusCode >= 300 { 5982 return out, metadata, awsRestjson1_deserializeOpErrorListAliases(response, &metadata) 5983 } 5984 output := &ListAliasesOutput{} 5985 out.Result = output 5986 5987 var buff [1024]byte 5988 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5989 5990 body := io.TeeReader(response.Body, ringBuffer) 5991 5992 decoder := json.NewDecoder(body) 5993 decoder.UseNumber() 5994 var shape interface{} 5995 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5996 var snapshot bytes.Buffer 5997 io.Copy(&snapshot, ringBuffer) 5998 err = &smithy.DeserializationError{ 5999 Err: fmt.Errorf("failed to decode response body, %w", err), 6000 Snapshot: snapshot.Bytes(), 6001 } 6002 return out, metadata, err 6003 } 6004 6005 err = awsRestjson1_deserializeOpDocumentListAliasesOutput(&output, shape) 6006 if err != nil { 6007 var snapshot bytes.Buffer 6008 io.Copy(&snapshot, ringBuffer) 6009 return out, metadata, &smithy.DeserializationError{ 6010 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6011 Snapshot: snapshot.Bytes(), 6012 } 6013 } 6014 6015 return out, metadata, err 6016} 6017 6018func awsRestjson1_deserializeOpErrorListAliases(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6019 var errorBuffer bytes.Buffer 6020 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6021 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6022 } 6023 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6024 6025 errorCode := "UnknownError" 6026 errorMessage := errorCode 6027 6028 code := response.Header.Get("X-Amzn-ErrorType") 6029 if len(code) != 0 { 6030 errorCode = restjson.SanitizeErrorCode(code) 6031 } 6032 6033 var buff [1024]byte 6034 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6035 6036 body := io.TeeReader(errorBody, ringBuffer) 6037 decoder := json.NewDecoder(body) 6038 decoder.UseNumber() 6039 code, message, err := restjson.GetErrorInfo(decoder) 6040 if err != nil { 6041 var snapshot bytes.Buffer 6042 io.Copy(&snapshot, ringBuffer) 6043 err = &smithy.DeserializationError{ 6044 Err: fmt.Errorf("failed to decode response body, %w", err), 6045 Snapshot: snapshot.Bytes(), 6046 } 6047 return err 6048 } 6049 6050 errorBody.Seek(0, io.SeekStart) 6051 if len(code) != 0 { 6052 errorCode = restjson.SanitizeErrorCode(code) 6053 } 6054 if len(message) != 0 { 6055 errorMessage = message 6056 } 6057 6058 switch { 6059 case strings.EqualFold("InvalidParameterValueException", errorCode): 6060 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 6061 6062 case strings.EqualFold("ResourceNotFoundException", errorCode): 6063 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6064 6065 case strings.EqualFold("ServiceException", errorCode): 6066 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 6067 6068 case strings.EqualFold("TooManyRequestsException", errorCode): 6069 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 6070 6071 default: 6072 genericError := &smithy.GenericAPIError{ 6073 Code: errorCode, 6074 Message: errorMessage, 6075 } 6076 return genericError 6077 6078 } 6079} 6080 6081func awsRestjson1_deserializeOpDocumentListAliasesOutput(v **ListAliasesOutput, value interface{}) error { 6082 if v == nil { 6083 return fmt.Errorf("unexpected nil of type %T", v) 6084 } 6085 if value == nil { 6086 return nil 6087 } 6088 6089 shape, ok := value.(map[string]interface{}) 6090 if !ok { 6091 return fmt.Errorf("unexpected JSON type %v", value) 6092 } 6093 6094 var sv *ListAliasesOutput 6095 if *v == nil { 6096 sv = &ListAliasesOutput{} 6097 } else { 6098 sv = *v 6099 } 6100 6101 for key, value := range shape { 6102 switch key { 6103 case "Aliases": 6104 if err := awsRestjson1_deserializeDocumentAliasList(&sv.Aliases, value); err != nil { 6105 return err 6106 } 6107 6108 case "NextMarker": 6109 if value != nil { 6110 jtv, ok := value.(string) 6111 if !ok { 6112 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6113 } 6114 sv.NextMarker = ptr.String(jtv) 6115 } 6116 6117 default: 6118 _, _ = key, value 6119 6120 } 6121 } 6122 *v = sv 6123 return nil 6124} 6125 6126type awsRestjson1_deserializeOpListCodeSigningConfigs struct { 6127} 6128 6129func (*awsRestjson1_deserializeOpListCodeSigningConfigs) ID() string { 6130 return "OperationDeserializer" 6131} 6132 6133func (m *awsRestjson1_deserializeOpListCodeSigningConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6134 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6135) { 6136 out, metadata, err = next.HandleDeserialize(ctx, in) 6137 if err != nil { 6138 return out, metadata, err 6139 } 6140 6141 response, ok := out.RawResponse.(*smithyhttp.Response) 6142 if !ok { 6143 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6144 } 6145 6146 if response.StatusCode < 200 || response.StatusCode >= 300 { 6147 return out, metadata, awsRestjson1_deserializeOpErrorListCodeSigningConfigs(response, &metadata) 6148 } 6149 output := &ListCodeSigningConfigsOutput{} 6150 out.Result = output 6151 6152 var buff [1024]byte 6153 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6154 6155 body := io.TeeReader(response.Body, ringBuffer) 6156 6157 decoder := json.NewDecoder(body) 6158 decoder.UseNumber() 6159 var shape interface{} 6160 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6161 var snapshot bytes.Buffer 6162 io.Copy(&snapshot, ringBuffer) 6163 err = &smithy.DeserializationError{ 6164 Err: fmt.Errorf("failed to decode response body, %w", err), 6165 Snapshot: snapshot.Bytes(), 6166 } 6167 return out, metadata, err 6168 } 6169 6170 err = awsRestjson1_deserializeOpDocumentListCodeSigningConfigsOutput(&output, shape) 6171 if err != nil { 6172 var snapshot bytes.Buffer 6173 io.Copy(&snapshot, ringBuffer) 6174 return out, metadata, &smithy.DeserializationError{ 6175 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6176 Snapshot: snapshot.Bytes(), 6177 } 6178 } 6179 6180 return out, metadata, err 6181} 6182 6183func awsRestjson1_deserializeOpErrorListCodeSigningConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6184 var errorBuffer bytes.Buffer 6185 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6186 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6187 } 6188 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6189 6190 errorCode := "UnknownError" 6191 errorMessage := errorCode 6192 6193 code := response.Header.Get("X-Amzn-ErrorType") 6194 if len(code) != 0 { 6195 errorCode = restjson.SanitizeErrorCode(code) 6196 } 6197 6198 var buff [1024]byte 6199 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6200 6201 body := io.TeeReader(errorBody, ringBuffer) 6202 decoder := json.NewDecoder(body) 6203 decoder.UseNumber() 6204 code, message, err := restjson.GetErrorInfo(decoder) 6205 if err != nil { 6206 var snapshot bytes.Buffer 6207 io.Copy(&snapshot, ringBuffer) 6208 err = &smithy.DeserializationError{ 6209 Err: fmt.Errorf("failed to decode response body, %w", err), 6210 Snapshot: snapshot.Bytes(), 6211 } 6212 return err 6213 } 6214 6215 errorBody.Seek(0, io.SeekStart) 6216 if len(code) != 0 { 6217 errorCode = restjson.SanitizeErrorCode(code) 6218 } 6219 if len(message) != 0 { 6220 errorMessage = message 6221 } 6222 6223 switch { 6224 case strings.EqualFold("InvalidParameterValueException", errorCode): 6225 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 6226 6227 case strings.EqualFold("ServiceException", errorCode): 6228 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 6229 6230 default: 6231 genericError := &smithy.GenericAPIError{ 6232 Code: errorCode, 6233 Message: errorMessage, 6234 } 6235 return genericError 6236 6237 } 6238} 6239 6240func awsRestjson1_deserializeOpDocumentListCodeSigningConfigsOutput(v **ListCodeSigningConfigsOutput, value interface{}) error { 6241 if v == nil { 6242 return fmt.Errorf("unexpected nil of type %T", v) 6243 } 6244 if value == nil { 6245 return nil 6246 } 6247 6248 shape, ok := value.(map[string]interface{}) 6249 if !ok { 6250 return fmt.Errorf("unexpected JSON type %v", value) 6251 } 6252 6253 var sv *ListCodeSigningConfigsOutput 6254 if *v == nil { 6255 sv = &ListCodeSigningConfigsOutput{} 6256 } else { 6257 sv = *v 6258 } 6259 6260 for key, value := range shape { 6261 switch key { 6262 case "CodeSigningConfigs": 6263 if err := awsRestjson1_deserializeDocumentCodeSigningConfigList(&sv.CodeSigningConfigs, value); err != nil { 6264 return err 6265 } 6266 6267 case "NextMarker": 6268 if value != nil { 6269 jtv, ok := value.(string) 6270 if !ok { 6271 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6272 } 6273 sv.NextMarker = ptr.String(jtv) 6274 } 6275 6276 default: 6277 _, _ = key, value 6278 6279 } 6280 } 6281 *v = sv 6282 return nil 6283} 6284 6285type awsRestjson1_deserializeOpListEventSourceMappings struct { 6286} 6287 6288func (*awsRestjson1_deserializeOpListEventSourceMappings) ID() string { 6289 return "OperationDeserializer" 6290} 6291 6292func (m *awsRestjson1_deserializeOpListEventSourceMappings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6293 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6294) { 6295 out, metadata, err = next.HandleDeserialize(ctx, in) 6296 if err != nil { 6297 return out, metadata, err 6298 } 6299 6300 response, ok := out.RawResponse.(*smithyhttp.Response) 6301 if !ok { 6302 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6303 } 6304 6305 if response.StatusCode < 200 || response.StatusCode >= 300 { 6306 return out, metadata, awsRestjson1_deserializeOpErrorListEventSourceMappings(response, &metadata) 6307 } 6308 output := &ListEventSourceMappingsOutput{} 6309 out.Result = output 6310 6311 var buff [1024]byte 6312 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6313 6314 body := io.TeeReader(response.Body, ringBuffer) 6315 6316 decoder := json.NewDecoder(body) 6317 decoder.UseNumber() 6318 var shape interface{} 6319 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6320 var snapshot bytes.Buffer 6321 io.Copy(&snapshot, ringBuffer) 6322 err = &smithy.DeserializationError{ 6323 Err: fmt.Errorf("failed to decode response body, %w", err), 6324 Snapshot: snapshot.Bytes(), 6325 } 6326 return out, metadata, err 6327 } 6328 6329 err = awsRestjson1_deserializeOpDocumentListEventSourceMappingsOutput(&output, shape) 6330 if err != nil { 6331 var snapshot bytes.Buffer 6332 io.Copy(&snapshot, ringBuffer) 6333 return out, metadata, &smithy.DeserializationError{ 6334 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6335 Snapshot: snapshot.Bytes(), 6336 } 6337 } 6338 6339 return out, metadata, err 6340} 6341 6342func awsRestjson1_deserializeOpErrorListEventSourceMappings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6343 var errorBuffer bytes.Buffer 6344 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6345 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6346 } 6347 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6348 6349 errorCode := "UnknownError" 6350 errorMessage := errorCode 6351 6352 code := response.Header.Get("X-Amzn-ErrorType") 6353 if len(code) != 0 { 6354 errorCode = restjson.SanitizeErrorCode(code) 6355 } 6356 6357 var buff [1024]byte 6358 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6359 6360 body := io.TeeReader(errorBody, ringBuffer) 6361 decoder := json.NewDecoder(body) 6362 decoder.UseNumber() 6363 code, message, err := restjson.GetErrorInfo(decoder) 6364 if err != nil { 6365 var snapshot bytes.Buffer 6366 io.Copy(&snapshot, ringBuffer) 6367 err = &smithy.DeserializationError{ 6368 Err: fmt.Errorf("failed to decode response body, %w", err), 6369 Snapshot: snapshot.Bytes(), 6370 } 6371 return err 6372 } 6373 6374 errorBody.Seek(0, io.SeekStart) 6375 if len(code) != 0 { 6376 errorCode = restjson.SanitizeErrorCode(code) 6377 } 6378 if len(message) != 0 { 6379 errorMessage = message 6380 } 6381 6382 switch { 6383 case strings.EqualFold("InvalidParameterValueException", errorCode): 6384 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 6385 6386 case strings.EqualFold("ResourceNotFoundException", errorCode): 6387 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6388 6389 case strings.EqualFold("ServiceException", errorCode): 6390 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 6391 6392 case strings.EqualFold("TooManyRequestsException", errorCode): 6393 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 6394 6395 default: 6396 genericError := &smithy.GenericAPIError{ 6397 Code: errorCode, 6398 Message: errorMessage, 6399 } 6400 return genericError 6401 6402 } 6403} 6404 6405func awsRestjson1_deserializeOpDocumentListEventSourceMappingsOutput(v **ListEventSourceMappingsOutput, value interface{}) error { 6406 if v == nil { 6407 return fmt.Errorf("unexpected nil of type %T", v) 6408 } 6409 if value == nil { 6410 return nil 6411 } 6412 6413 shape, ok := value.(map[string]interface{}) 6414 if !ok { 6415 return fmt.Errorf("unexpected JSON type %v", value) 6416 } 6417 6418 var sv *ListEventSourceMappingsOutput 6419 if *v == nil { 6420 sv = &ListEventSourceMappingsOutput{} 6421 } else { 6422 sv = *v 6423 } 6424 6425 for key, value := range shape { 6426 switch key { 6427 case "EventSourceMappings": 6428 if err := awsRestjson1_deserializeDocumentEventSourceMappingsList(&sv.EventSourceMappings, value); err != nil { 6429 return err 6430 } 6431 6432 case "NextMarker": 6433 if value != nil { 6434 jtv, ok := value.(string) 6435 if !ok { 6436 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6437 } 6438 sv.NextMarker = ptr.String(jtv) 6439 } 6440 6441 default: 6442 _, _ = key, value 6443 6444 } 6445 } 6446 *v = sv 6447 return nil 6448} 6449 6450type awsRestjson1_deserializeOpListFunctionEventInvokeConfigs struct { 6451} 6452 6453func (*awsRestjson1_deserializeOpListFunctionEventInvokeConfigs) ID() string { 6454 return "OperationDeserializer" 6455} 6456 6457func (m *awsRestjson1_deserializeOpListFunctionEventInvokeConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6458 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6459) { 6460 out, metadata, err = next.HandleDeserialize(ctx, in) 6461 if err != nil { 6462 return out, metadata, err 6463 } 6464 6465 response, ok := out.RawResponse.(*smithyhttp.Response) 6466 if !ok { 6467 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6468 } 6469 6470 if response.StatusCode < 200 || response.StatusCode >= 300 { 6471 return out, metadata, awsRestjson1_deserializeOpErrorListFunctionEventInvokeConfigs(response, &metadata) 6472 } 6473 output := &ListFunctionEventInvokeConfigsOutput{} 6474 out.Result = output 6475 6476 var buff [1024]byte 6477 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6478 6479 body := io.TeeReader(response.Body, ringBuffer) 6480 6481 decoder := json.NewDecoder(body) 6482 decoder.UseNumber() 6483 var shape interface{} 6484 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6485 var snapshot bytes.Buffer 6486 io.Copy(&snapshot, ringBuffer) 6487 err = &smithy.DeserializationError{ 6488 Err: fmt.Errorf("failed to decode response body, %w", err), 6489 Snapshot: snapshot.Bytes(), 6490 } 6491 return out, metadata, err 6492 } 6493 6494 err = awsRestjson1_deserializeOpDocumentListFunctionEventInvokeConfigsOutput(&output, shape) 6495 if err != nil { 6496 var snapshot bytes.Buffer 6497 io.Copy(&snapshot, ringBuffer) 6498 return out, metadata, &smithy.DeserializationError{ 6499 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6500 Snapshot: snapshot.Bytes(), 6501 } 6502 } 6503 6504 return out, metadata, err 6505} 6506 6507func awsRestjson1_deserializeOpErrorListFunctionEventInvokeConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6508 var errorBuffer bytes.Buffer 6509 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6510 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6511 } 6512 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6513 6514 errorCode := "UnknownError" 6515 errorMessage := errorCode 6516 6517 code := response.Header.Get("X-Amzn-ErrorType") 6518 if len(code) != 0 { 6519 errorCode = restjson.SanitizeErrorCode(code) 6520 } 6521 6522 var buff [1024]byte 6523 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6524 6525 body := io.TeeReader(errorBody, ringBuffer) 6526 decoder := json.NewDecoder(body) 6527 decoder.UseNumber() 6528 code, message, err := restjson.GetErrorInfo(decoder) 6529 if err != nil { 6530 var snapshot bytes.Buffer 6531 io.Copy(&snapshot, ringBuffer) 6532 err = &smithy.DeserializationError{ 6533 Err: fmt.Errorf("failed to decode response body, %w", err), 6534 Snapshot: snapshot.Bytes(), 6535 } 6536 return err 6537 } 6538 6539 errorBody.Seek(0, io.SeekStart) 6540 if len(code) != 0 { 6541 errorCode = restjson.SanitizeErrorCode(code) 6542 } 6543 if len(message) != 0 { 6544 errorMessage = message 6545 } 6546 6547 switch { 6548 case strings.EqualFold("InvalidParameterValueException", errorCode): 6549 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 6550 6551 case strings.EqualFold("ResourceNotFoundException", errorCode): 6552 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6553 6554 case strings.EqualFold("ServiceException", errorCode): 6555 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 6556 6557 case strings.EqualFold("TooManyRequestsException", errorCode): 6558 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 6559 6560 default: 6561 genericError := &smithy.GenericAPIError{ 6562 Code: errorCode, 6563 Message: errorMessage, 6564 } 6565 return genericError 6566 6567 } 6568} 6569 6570func awsRestjson1_deserializeOpDocumentListFunctionEventInvokeConfigsOutput(v **ListFunctionEventInvokeConfigsOutput, value interface{}) error { 6571 if v == nil { 6572 return fmt.Errorf("unexpected nil of type %T", v) 6573 } 6574 if value == nil { 6575 return nil 6576 } 6577 6578 shape, ok := value.(map[string]interface{}) 6579 if !ok { 6580 return fmt.Errorf("unexpected JSON type %v", value) 6581 } 6582 6583 var sv *ListFunctionEventInvokeConfigsOutput 6584 if *v == nil { 6585 sv = &ListFunctionEventInvokeConfigsOutput{} 6586 } else { 6587 sv = *v 6588 } 6589 6590 for key, value := range shape { 6591 switch key { 6592 case "FunctionEventInvokeConfigs": 6593 if err := awsRestjson1_deserializeDocumentFunctionEventInvokeConfigList(&sv.FunctionEventInvokeConfigs, value); err != nil { 6594 return err 6595 } 6596 6597 case "NextMarker": 6598 if value != nil { 6599 jtv, ok := value.(string) 6600 if !ok { 6601 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6602 } 6603 sv.NextMarker = ptr.String(jtv) 6604 } 6605 6606 default: 6607 _, _ = key, value 6608 6609 } 6610 } 6611 *v = sv 6612 return nil 6613} 6614 6615type awsRestjson1_deserializeOpListFunctions struct { 6616} 6617 6618func (*awsRestjson1_deserializeOpListFunctions) ID() string { 6619 return "OperationDeserializer" 6620} 6621 6622func (m *awsRestjson1_deserializeOpListFunctions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6623 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6624) { 6625 out, metadata, err = next.HandleDeserialize(ctx, in) 6626 if err != nil { 6627 return out, metadata, err 6628 } 6629 6630 response, ok := out.RawResponse.(*smithyhttp.Response) 6631 if !ok { 6632 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6633 } 6634 6635 if response.StatusCode < 200 || response.StatusCode >= 300 { 6636 return out, metadata, awsRestjson1_deserializeOpErrorListFunctions(response, &metadata) 6637 } 6638 output := &ListFunctionsOutput{} 6639 out.Result = output 6640 6641 var buff [1024]byte 6642 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6643 6644 body := io.TeeReader(response.Body, ringBuffer) 6645 6646 decoder := json.NewDecoder(body) 6647 decoder.UseNumber() 6648 var shape interface{} 6649 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6650 var snapshot bytes.Buffer 6651 io.Copy(&snapshot, ringBuffer) 6652 err = &smithy.DeserializationError{ 6653 Err: fmt.Errorf("failed to decode response body, %w", err), 6654 Snapshot: snapshot.Bytes(), 6655 } 6656 return out, metadata, err 6657 } 6658 6659 err = awsRestjson1_deserializeOpDocumentListFunctionsOutput(&output, shape) 6660 if err != nil { 6661 var snapshot bytes.Buffer 6662 io.Copy(&snapshot, ringBuffer) 6663 return out, metadata, &smithy.DeserializationError{ 6664 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6665 Snapshot: snapshot.Bytes(), 6666 } 6667 } 6668 6669 return out, metadata, err 6670} 6671 6672func awsRestjson1_deserializeOpErrorListFunctions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6673 var errorBuffer bytes.Buffer 6674 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6675 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6676 } 6677 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6678 6679 errorCode := "UnknownError" 6680 errorMessage := errorCode 6681 6682 code := response.Header.Get("X-Amzn-ErrorType") 6683 if len(code) != 0 { 6684 errorCode = restjson.SanitizeErrorCode(code) 6685 } 6686 6687 var buff [1024]byte 6688 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6689 6690 body := io.TeeReader(errorBody, ringBuffer) 6691 decoder := json.NewDecoder(body) 6692 decoder.UseNumber() 6693 code, message, err := restjson.GetErrorInfo(decoder) 6694 if err != nil { 6695 var snapshot bytes.Buffer 6696 io.Copy(&snapshot, ringBuffer) 6697 err = &smithy.DeserializationError{ 6698 Err: fmt.Errorf("failed to decode response body, %w", err), 6699 Snapshot: snapshot.Bytes(), 6700 } 6701 return err 6702 } 6703 6704 errorBody.Seek(0, io.SeekStart) 6705 if len(code) != 0 { 6706 errorCode = restjson.SanitizeErrorCode(code) 6707 } 6708 if len(message) != 0 { 6709 errorMessage = message 6710 } 6711 6712 switch { 6713 case strings.EqualFold("InvalidParameterValueException", errorCode): 6714 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 6715 6716 case strings.EqualFold("ServiceException", errorCode): 6717 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 6718 6719 case strings.EqualFold("TooManyRequestsException", errorCode): 6720 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 6721 6722 default: 6723 genericError := &smithy.GenericAPIError{ 6724 Code: errorCode, 6725 Message: errorMessage, 6726 } 6727 return genericError 6728 6729 } 6730} 6731 6732func awsRestjson1_deserializeOpDocumentListFunctionsOutput(v **ListFunctionsOutput, value interface{}) error { 6733 if v == nil { 6734 return fmt.Errorf("unexpected nil of type %T", v) 6735 } 6736 if value == nil { 6737 return nil 6738 } 6739 6740 shape, ok := value.(map[string]interface{}) 6741 if !ok { 6742 return fmt.Errorf("unexpected JSON type %v", value) 6743 } 6744 6745 var sv *ListFunctionsOutput 6746 if *v == nil { 6747 sv = &ListFunctionsOutput{} 6748 } else { 6749 sv = *v 6750 } 6751 6752 for key, value := range shape { 6753 switch key { 6754 case "Functions": 6755 if err := awsRestjson1_deserializeDocumentFunctionList(&sv.Functions, value); err != nil { 6756 return err 6757 } 6758 6759 case "NextMarker": 6760 if value != nil { 6761 jtv, ok := value.(string) 6762 if !ok { 6763 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6764 } 6765 sv.NextMarker = ptr.String(jtv) 6766 } 6767 6768 default: 6769 _, _ = key, value 6770 6771 } 6772 } 6773 *v = sv 6774 return nil 6775} 6776 6777type awsRestjson1_deserializeOpListFunctionsByCodeSigningConfig struct { 6778} 6779 6780func (*awsRestjson1_deserializeOpListFunctionsByCodeSigningConfig) ID() string { 6781 return "OperationDeserializer" 6782} 6783 6784func (m *awsRestjson1_deserializeOpListFunctionsByCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6785 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6786) { 6787 out, metadata, err = next.HandleDeserialize(ctx, in) 6788 if err != nil { 6789 return out, metadata, err 6790 } 6791 6792 response, ok := out.RawResponse.(*smithyhttp.Response) 6793 if !ok { 6794 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6795 } 6796 6797 if response.StatusCode < 200 || response.StatusCode >= 300 { 6798 return out, metadata, awsRestjson1_deserializeOpErrorListFunctionsByCodeSigningConfig(response, &metadata) 6799 } 6800 output := &ListFunctionsByCodeSigningConfigOutput{} 6801 out.Result = output 6802 6803 var buff [1024]byte 6804 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6805 6806 body := io.TeeReader(response.Body, ringBuffer) 6807 6808 decoder := json.NewDecoder(body) 6809 decoder.UseNumber() 6810 var shape interface{} 6811 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6812 var snapshot bytes.Buffer 6813 io.Copy(&snapshot, ringBuffer) 6814 err = &smithy.DeserializationError{ 6815 Err: fmt.Errorf("failed to decode response body, %w", err), 6816 Snapshot: snapshot.Bytes(), 6817 } 6818 return out, metadata, err 6819 } 6820 6821 err = awsRestjson1_deserializeOpDocumentListFunctionsByCodeSigningConfigOutput(&output, shape) 6822 if err != nil { 6823 var snapshot bytes.Buffer 6824 io.Copy(&snapshot, ringBuffer) 6825 return out, metadata, &smithy.DeserializationError{ 6826 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6827 Snapshot: snapshot.Bytes(), 6828 } 6829 } 6830 6831 return out, metadata, err 6832} 6833 6834func awsRestjson1_deserializeOpErrorListFunctionsByCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6835 var errorBuffer bytes.Buffer 6836 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6837 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6838 } 6839 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6840 6841 errorCode := "UnknownError" 6842 errorMessage := errorCode 6843 6844 code := response.Header.Get("X-Amzn-ErrorType") 6845 if len(code) != 0 { 6846 errorCode = restjson.SanitizeErrorCode(code) 6847 } 6848 6849 var buff [1024]byte 6850 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6851 6852 body := io.TeeReader(errorBody, ringBuffer) 6853 decoder := json.NewDecoder(body) 6854 decoder.UseNumber() 6855 code, message, err := restjson.GetErrorInfo(decoder) 6856 if err != nil { 6857 var snapshot bytes.Buffer 6858 io.Copy(&snapshot, ringBuffer) 6859 err = &smithy.DeserializationError{ 6860 Err: fmt.Errorf("failed to decode response body, %w", err), 6861 Snapshot: snapshot.Bytes(), 6862 } 6863 return err 6864 } 6865 6866 errorBody.Seek(0, io.SeekStart) 6867 if len(code) != 0 { 6868 errorCode = restjson.SanitizeErrorCode(code) 6869 } 6870 if len(message) != 0 { 6871 errorMessage = message 6872 } 6873 6874 switch { 6875 case strings.EqualFold("InvalidParameterValueException", errorCode): 6876 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 6877 6878 case strings.EqualFold("ResourceNotFoundException", errorCode): 6879 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6880 6881 case strings.EqualFold("ServiceException", errorCode): 6882 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 6883 6884 default: 6885 genericError := &smithy.GenericAPIError{ 6886 Code: errorCode, 6887 Message: errorMessage, 6888 } 6889 return genericError 6890 6891 } 6892} 6893 6894func awsRestjson1_deserializeOpDocumentListFunctionsByCodeSigningConfigOutput(v **ListFunctionsByCodeSigningConfigOutput, value interface{}) error { 6895 if v == nil { 6896 return fmt.Errorf("unexpected nil of type %T", v) 6897 } 6898 if value == nil { 6899 return nil 6900 } 6901 6902 shape, ok := value.(map[string]interface{}) 6903 if !ok { 6904 return fmt.Errorf("unexpected JSON type %v", value) 6905 } 6906 6907 var sv *ListFunctionsByCodeSigningConfigOutput 6908 if *v == nil { 6909 sv = &ListFunctionsByCodeSigningConfigOutput{} 6910 } else { 6911 sv = *v 6912 } 6913 6914 for key, value := range shape { 6915 switch key { 6916 case "FunctionArns": 6917 if err := awsRestjson1_deserializeDocumentFunctionArnList(&sv.FunctionArns, value); err != nil { 6918 return err 6919 } 6920 6921 case "NextMarker": 6922 if value != nil { 6923 jtv, ok := value.(string) 6924 if !ok { 6925 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6926 } 6927 sv.NextMarker = ptr.String(jtv) 6928 } 6929 6930 default: 6931 _, _ = key, value 6932 6933 } 6934 } 6935 *v = sv 6936 return nil 6937} 6938 6939type awsRestjson1_deserializeOpListLayers struct { 6940} 6941 6942func (*awsRestjson1_deserializeOpListLayers) ID() string { 6943 return "OperationDeserializer" 6944} 6945 6946func (m *awsRestjson1_deserializeOpListLayers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6947 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6948) { 6949 out, metadata, err = next.HandleDeserialize(ctx, in) 6950 if err != nil { 6951 return out, metadata, err 6952 } 6953 6954 response, ok := out.RawResponse.(*smithyhttp.Response) 6955 if !ok { 6956 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6957 } 6958 6959 if response.StatusCode < 200 || response.StatusCode >= 300 { 6960 return out, metadata, awsRestjson1_deserializeOpErrorListLayers(response, &metadata) 6961 } 6962 output := &ListLayersOutput{} 6963 out.Result = output 6964 6965 var buff [1024]byte 6966 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6967 6968 body := io.TeeReader(response.Body, ringBuffer) 6969 6970 decoder := json.NewDecoder(body) 6971 decoder.UseNumber() 6972 var shape interface{} 6973 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6974 var snapshot bytes.Buffer 6975 io.Copy(&snapshot, ringBuffer) 6976 err = &smithy.DeserializationError{ 6977 Err: fmt.Errorf("failed to decode response body, %w", err), 6978 Snapshot: snapshot.Bytes(), 6979 } 6980 return out, metadata, err 6981 } 6982 6983 err = awsRestjson1_deserializeOpDocumentListLayersOutput(&output, shape) 6984 if err != nil { 6985 var snapshot bytes.Buffer 6986 io.Copy(&snapshot, ringBuffer) 6987 return out, metadata, &smithy.DeserializationError{ 6988 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6989 Snapshot: snapshot.Bytes(), 6990 } 6991 } 6992 6993 return out, metadata, err 6994} 6995 6996func awsRestjson1_deserializeOpErrorListLayers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6997 var errorBuffer bytes.Buffer 6998 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6999 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7000 } 7001 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7002 7003 errorCode := "UnknownError" 7004 errorMessage := errorCode 7005 7006 code := response.Header.Get("X-Amzn-ErrorType") 7007 if len(code) != 0 { 7008 errorCode = restjson.SanitizeErrorCode(code) 7009 } 7010 7011 var buff [1024]byte 7012 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7013 7014 body := io.TeeReader(errorBody, ringBuffer) 7015 decoder := json.NewDecoder(body) 7016 decoder.UseNumber() 7017 code, message, err := restjson.GetErrorInfo(decoder) 7018 if err != nil { 7019 var snapshot bytes.Buffer 7020 io.Copy(&snapshot, ringBuffer) 7021 err = &smithy.DeserializationError{ 7022 Err: fmt.Errorf("failed to decode response body, %w", err), 7023 Snapshot: snapshot.Bytes(), 7024 } 7025 return err 7026 } 7027 7028 errorBody.Seek(0, io.SeekStart) 7029 if len(code) != 0 { 7030 errorCode = restjson.SanitizeErrorCode(code) 7031 } 7032 if len(message) != 0 { 7033 errorMessage = message 7034 } 7035 7036 switch { 7037 case strings.EqualFold("InvalidParameterValueException", errorCode): 7038 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 7039 7040 case strings.EqualFold("ServiceException", errorCode): 7041 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 7042 7043 case strings.EqualFold("TooManyRequestsException", errorCode): 7044 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 7045 7046 default: 7047 genericError := &smithy.GenericAPIError{ 7048 Code: errorCode, 7049 Message: errorMessage, 7050 } 7051 return genericError 7052 7053 } 7054} 7055 7056func awsRestjson1_deserializeOpDocumentListLayersOutput(v **ListLayersOutput, value interface{}) error { 7057 if v == nil { 7058 return fmt.Errorf("unexpected nil of type %T", v) 7059 } 7060 if value == nil { 7061 return nil 7062 } 7063 7064 shape, ok := value.(map[string]interface{}) 7065 if !ok { 7066 return fmt.Errorf("unexpected JSON type %v", value) 7067 } 7068 7069 var sv *ListLayersOutput 7070 if *v == nil { 7071 sv = &ListLayersOutput{} 7072 } else { 7073 sv = *v 7074 } 7075 7076 for key, value := range shape { 7077 switch key { 7078 case "Layers": 7079 if err := awsRestjson1_deserializeDocumentLayersList(&sv.Layers, value); err != nil { 7080 return err 7081 } 7082 7083 case "NextMarker": 7084 if value != nil { 7085 jtv, ok := value.(string) 7086 if !ok { 7087 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7088 } 7089 sv.NextMarker = ptr.String(jtv) 7090 } 7091 7092 default: 7093 _, _ = key, value 7094 7095 } 7096 } 7097 *v = sv 7098 return nil 7099} 7100 7101type awsRestjson1_deserializeOpListLayerVersions struct { 7102} 7103 7104func (*awsRestjson1_deserializeOpListLayerVersions) ID() string { 7105 return "OperationDeserializer" 7106} 7107 7108func (m *awsRestjson1_deserializeOpListLayerVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7109 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7110) { 7111 out, metadata, err = next.HandleDeserialize(ctx, in) 7112 if err != nil { 7113 return out, metadata, err 7114 } 7115 7116 response, ok := out.RawResponse.(*smithyhttp.Response) 7117 if !ok { 7118 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7119 } 7120 7121 if response.StatusCode < 200 || response.StatusCode >= 300 { 7122 return out, metadata, awsRestjson1_deserializeOpErrorListLayerVersions(response, &metadata) 7123 } 7124 output := &ListLayerVersionsOutput{} 7125 out.Result = output 7126 7127 var buff [1024]byte 7128 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7129 7130 body := io.TeeReader(response.Body, ringBuffer) 7131 7132 decoder := json.NewDecoder(body) 7133 decoder.UseNumber() 7134 var shape interface{} 7135 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7136 var snapshot bytes.Buffer 7137 io.Copy(&snapshot, ringBuffer) 7138 err = &smithy.DeserializationError{ 7139 Err: fmt.Errorf("failed to decode response body, %w", err), 7140 Snapshot: snapshot.Bytes(), 7141 } 7142 return out, metadata, err 7143 } 7144 7145 err = awsRestjson1_deserializeOpDocumentListLayerVersionsOutput(&output, shape) 7146 if err != nil { 7147 var snapshot bytes.Buffer 7148 io.Copy(&snapshot, ringBuffer) 7149 return out, metadata, &smithy.DeserializationError{ 7150 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7151 Snapshot: snapshot.Bytes(), 7152 } 7153 } 7154 7155 return out, metadata, err 7156} 7157 7158func awsRestjson1_deserializeOpErrorListLayerVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7159 var errorBuffer bytes.Buffer 7160 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7161 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7162 } 7163 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7164 7165 errorCode := "UnknownError" 7166 errorMessage := errorCode 7167 7168 code := response.Header.Get("X-Amzn-ErrorType") 7169 if len(code) != 0 { 7170 errorCode = restjson.SanitizeErrorCode(code) 7171 } 7172 7173 var buff [1024]byte 7174 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7175 7176 body := io.TeeReader(errorBody, ringBuffer) 7177 decoder := json.NewDecoder(body) 7178 decoder.UseNumber() 7179 code, message, err := restjson.GetErrorInfo(decoder) 7180 if err != nil { 7181 var snapshot bytes.Buffer 7182 io.Copy(&snapshot, ringBuffer) 7183 err = &smithy.DeserializationError{ 7184 Err: fmt.Errorf("failed to decode response body, %w", err), 7185 Snapshot: snapshot.Bytes(), 7186 } 7187 return err 7188 } 7189 7190 errorBody.Seek(0, io.SeekStart) 7191 if len(code) != 0 { 7192 errorCode = restjson.SanitizeErrorCode(code) 7193 } 7194 if len(message) != 0 { 7195 errorMessage = message 7196 } 7197 7198 switch { 7199 case strings.EqualFold("InvalidParameterValueException", errorCode): 7200 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 7201 7202 case strings.EqualFold("ResourceNotFoundException", errorCode): 7203 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7204 7205 case strings.EqualFold("ServiceException", errorCode): 7206 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 7207 7208 case strings.EqualFold("TooManyRequestsException", errorCode): 7209 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 7210 7211 default: 7212 genericError := &smithy.GenericAPIError{ 7213 Code: errorCode, 7214 Message: errorMessage, 7215 } 7216 return genericError 7217 7218 } 7219} 7220 7221func awsRestjson1_deserializeOpDocumentListLayerVersionsOutput(v **ListLayerVersionsOutput, value interface{}) error { 7222 if v == nil { 7223 return fmt.Errorf("unexpected nil of type %T", v) 7224 } 7225 if value == nil { 7226 return nil 7227 } 7228 7229 shape, ok := value.(map[string]interface{}) 7230 if !ok { 7231 return fmt.Errorf("unexpected JSON type %v", value) 7232 } 7233 7234 var sv *ListLayerVersionsOutput 7235 if *v == nil { 7236 sv = &ListLayerVersionsOutput{} 7237 } else { 7238 sv = *v 7239 } 7240 7241 for key, value := range shape { 7242 switch key { 7243 case "LayerVersions": 7244 if err := awsRestjson1_deserializeDocumentLayerVersionsList(&sv.LayerVersions, value); err != nil { 7245 return err 7246 } 7247 7248 case "NextMarker": 7249 if value != nil { 7250 jtv, ok := value.(string) 7251 if !ok { 7252 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7253 } 7254 sv.NextMarker = ptr.String(jtv) 7255 } 7256 7257 default: 7258 _, _ = key, value 7259 7260 } 7261 } 7262 *v = sv 7263 return nil 7264} 7265 7266type awsRestjson1_deserializeOpListProvisionedConcurrencyConfigs struct { 7267} 7268 7269func (*awsRestjson1_deserializeOpListProvisionedConcurrencyConfigs) ID() string { 7270 return "OperationDeserializer" 7271} 7272 7273func (m *awsRestjson1_deserializeOpListProvisionedConcurrencyConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7274 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7275) { 7276 out, metadata, err = next.HandleDeserialize(ctx, in) 7277 if err != nil { 7278 return out, metadata, err 7279 } 7280 7281 response, ok := out.RawResponse.(*smithyhttp.Response) 7282 if !ok { 7283 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7284 } 7285 7286 if response.StatusCode < 200 || response.StatusCode >= 300 { 7287 return out, metadata, awsRestjson1_deserializeOpErrorListProvisionedConcurrencyConfigs(response, &metadata) 7288 } 7289 output := &ListProvisionedConcurrencyConfigsOutput{} 7290 out.Result = output 7291 7292 var buff [1024]byte 7293 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7294 7295 body := io.TeeReader(response.Body, ringBuffer) 7296 7297 decoder := json.NewDecoder(body) 7298 decoder.UseNumber() 7299 var shape interface{} 7300 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7301 var snapshot bytes.Buffer 7302 io.Copy(&snapshot, ringBuffer) 7303 err = &smithy.DeserializationError{ 7304 Err: fmt.Errorf("failed to decode response body, %w", err), 7305 Snapshot: snapshot.Bytes(), 7306 } 7307 return out, metadata, err 7308 } 7309 7310 err = awsRestjson1_deserializeOpDocumentListProvisionedConcurrencyConfigsOutput(&output, shape) 7311 if err != nil { 7312 var snapshot bytes.Buffer 7313 io.Copy(&snapshot, ringBuffer) 7314 return out, metadata, &smithy.DeserializationError{ 7315 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7316 Snapshot: snapshot.Bytes(), 7317 } 7318 } 7319 7320 return out, metadata, err 7321} 7322 7323func awsRestjson1_deserializeOpErrorListProvisionedConcurrencyConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7324 var errorBuffer bytes.Buffer 7325 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7326 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7327 } 7328 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7329 7330 errorCode := "UnknownError" 7331 errorMessage := errorCode 7332 7333 code := response.Header.Get("X-Amzn-ErrorType") 7334 if len(code) != 0 { 7335 errorCode = restjson.SanitizeErrorCode(code) 7336 } 7337 7338 var buff [1024]byte 7339 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7340 7341 body := io.TeeReader(errorBody, ringBuffer) 7342 decoder := json.NewDecoder(body) 7343 decoder.UseNumber() 7344 code, message, err := restjson.GetErrorInfo(decoder) 7345 if err != nil { 7346 var snapshot bytes.Buffer 7347 io.Copy(&snapshot, ringBuffer) 7348 err = &smithy.DeserializationError{ 7349 Err: fmt.Errorf("failed to decode response body, %w", err), 7350 Snapshot: snapshot.Bytes(), 7351 } 7352 return err 7353 } 7354 7355 errorBody.Seek(0, io.SeekStart) 7356 if len(code) != 0 { 7357 errorCode = restjson.SanitizeErrorCode(code) 7358 } 7359 if len(message) != 0 { 7360 errorMessage = message 7361 } 7362 7363 switch { 7364 case strings.EqualFold("InvalidParameterValueException", errorCode): 7365 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 7366 7367 case strings.EqualFold("ResourceNotFoundException", errorCode): 7368 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7369 7370 case strings.EqualFold("ServiceException", errorCode): 7371 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 7372 7373 case strings.EqualFold("TooManyRequestsException", errorCode): 7374 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 7375 7376 default: 7377 genericError := &smithy.GenericAPIError{ 7378 Code: errorCode, 7379 Message: errorMessage, 7380 } 7381 return genericError 7382 7383 } 7384} 7385 7386func awsRestjson1_deserializeOpDocumentListProvisionedConcurrencyConfigsOutput(v **ListProvisionedConcurrencyConfigsOutput, value interface{}) error { 7387 if v == nil { 7388 return fmt.Errorf("unexpected nil of type %T", v) 7389 } 7390 if value == nil { 7391 return nil 7392 } 7393 7394 shape, ok := value.(map[string]interface{}) 7395 if !ok { 7396 return fmt.Errorf("unexpected JSON type %v", value) 7397 } 7398 7399 var sv *ListProvisionedConcurrencyConfigsOutput 7400 if *v == nil { 7401 sv = &ListProvisionedConcurrencyConfigsOutput{} 7402 } else { 7403 sv = *v 7404 } 7405 7406 for key, value := range shape { 7407 switch key { 7408 case "NextMarker": 7409 if value != nil { 7410 jtv, ok := value.(string) 7411 if !ok { 7412 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7413 } 7414 sv.NextMarker = ptr.String(jtv) 7415 } 7416 7417 case "ProvisionedConcurrencyConfigs": 7418 if err := awsRestjson1_deserializeDocumentProvisionedConcurrencyConfigList(&sv.ProvisionedConcurrencyConfigs, value); err != nil { 7419 return err 7420 } 7421 7422 default: 7423 _, _ = key, value 7424 7425 } 7426 } 7427 *v = sv 7428 return nil 7429} 7430 7431type awsRestjson1_deserializeOpListTags struct { 7432} 7433 7434func (*awsRestjson1_deserializeOpListTags) ID() string { 7435 return "OperationDeserializer" 7436} 7437 7438func (m *awsRestjson1_deserializeOpListTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7439 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7440) { 7441 out, metadata, err = next.HandleDeserialize(ctx, in) 7442 if err != nil { 7443 return out, metadata, err 7444 } 7445 7446 response, ok := out.RawResponse.(*smithyhttp.Response) 7447 if !ok { 7448 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7449 } 7450 7451 if response.StatusCode < 200 || response.StatusCode >= 300 { 7452 return out, metadata, awsRestjson1_deserializeOpErrorListTags(response, &metadata) 7453 } 7454 output := &ListTagsOutput{} 7455 out.Result = output 7456 7457 var buff [1024]byte 7458 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7459 7460 body := io.TeeReader(response.Body, ringBuffer) 7461 7462 decoder := json.NewDecoder(body) 7463 decoder.UseNumber() 7464 var shape interface{} 7465 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7466 var snapshot bytes.Buffer 7467 io.Copy(&snapshot, ringBuffer) 7468 err = &smithy.DeserializationError{ 7469 Err: fmt.Errorf("failed to decode response body, %w", err), 7470 Snapshot: snapshot.Bytes(), 7471 } 7472 return out, metadata, err 7473 } 7474 7475 err = awsRestjson1_deserializeOpDocumentListTagsOutput(&output, shape) 7476 if err != nil { 7477 var snapshot bytes.Buffer 7478 io.Copy(&snapshot, ringBuffer) 7479 return out, metadata, &smithy.DeserializationError{ 7480 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7481 Snapshot: snapshot.Bytes(), 7482 } 7483 } 7484 7485 return out, metadata, err 7486} 7487 7488func awsRestjson1_deserializeOpErrorListTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7489 var errorBuffer bytes.Buffer 7490 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7491 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7492 } 7493 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7494 7495 errorCode := "UnknownError" 7496 errorMessage := errorCode 7497 7498 code := response.Header.Get("X-Amzn-ErrorType") 7499 if len(code) != 0 { 7500 errorCode = restjson.SanitizeErrorCode(code) 7501 } 7502 7503 var buff [1024]byte 7504 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7505 7506 body := io.TeeReader(errorBody, ringBuffer) 7507 decoder := json.NewDecoder(body) 7508 decoder.UseNumber() 7509 code, message, err := restjson.GetErrorInfo(decoder) 7510 if err != nil { 7511 var snapshot bytes.Buffer 7512 io.Copy(&snapshot, ringBuffer) 7513 err = &smithy.DeserializationError{ 7514 Err: fmt.Errorf("failed to decode response body, %w", err), 7515 Snapshot: snapshot.Bytes(), 7516 } 7517 return err 7518 } 7519 7520 errorBody.Seek(0, io.SeekStart) 7521 if len(code) != 0 { 7522 errorCode = restjson.SanitizeErrorCode(code) 7523 } 7524 if len(message) != 0 { 7525 errorMessage = message 7526 } 7527 7528 switch { 7529 case strings.EqualFold("InvalidParameterValueException", errorCode): 7530 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 7531 7532 case strings.EqualFold("ResourceNotFoundException", errorCode): 7533 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7534 7535 case strings.EqualFold("ServiceException", errorCode): 7536 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 7537 7538 case strings.EqualFold("TooManyRequestsException", errorCode): 7539 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 7540 7541 default: 7542 genericError := &smithy.GenericAPIError{ 7543 Code: errorCode, 7544 Message: errorMessage, 7545 } 7546 return genericError 7547 7548 } 7549} 7550 7551func awsRestjson1_deserializeOpDocumentListTagsOutput(v **ListTagsOutput, value interface{}) error { 7552 if v == nil { 7553 return fmt.Errorf("unexpected nil of type %T", v) 7554 } 7555 if value == nil { 7556 return nil 7557 } 7558 7559 shape, ok := value.(map[string]interface{}) 7560 if !ok { 7561 return fmt.Errorf("unexpected JSON type %v", value) 7562 } 7563 7564 var sv *ListTagsOutput 7565 if *v == nil { 7566 sv = &ListTagsOutput{} 7567 } else { 7568 sv = *v 7569 } 7570 7571 for key, value := range shape { 7572 switch key { 7573 case "Tags": 7574 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 7575 return err 7576 } 7577 7578 default: 7579 _, _ = key, value 7580 7581 } 7582 } 7583 *v = sv 7584 return nil 7585} 7586 7587type awsRestjson1_deserializeOpListVersionsByFunction struct { 7588} 7589 7590func (*awsRestjson1_deserializeOpListVersionsByFunction) ID() string { 7591 return "OperationDeserializer" 7592} 7593 7594func (m *awsRestjson1_deserializeOpListVersionsByFunction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7595 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7596) { 7597 out, metadata, err = next.HandleDeserialize(ctx, in) 7598 if err != nil { 7599 return out, metadata, err 7600 } 7601 7602 response, ok := out.RawResponse.(*smithyhttp.Response) 7603 if !ok { 7604 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7605 } 7606 7607 if response.StatusCode < 200 || response.StatusCode >= 300 { 7608 return out, metadata, awsRestjson1_deserializeOpErrorListVersionsByFunction(response, &metadata) 7609 } 7610 output := &ListVersionsByFunctionOutput{} 7611 out.Result = output 7612 7613 var buff [1024]byte 7614 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7615 7616 body := io.TeeReader(response.Body, ringBuffer) 7617 7618 decoder := json.NewDecoder(body) 7619 decoder.UseNumber() 7620 var shape interface{} 7621 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7622 var snapshot bytes.Buffer 7623 io.Copy(&snapshot, ringBuffer) 7624 err = &smithy.DeserializationError{ 7625 Err: fmt.Errorf("failed to decode response body, %w", err), 7626 Snapshot: snapshot.Bytes(), 7627 } 7628 return out, metadata, err 7629 } 7630 7631 err = awsRestjson1_deserializeOpDocumentListVersionsByFunctionOutput(&output, shape) 7632 if err != nil { 7633 var snapshot bytes.Buffer 7634 io.Copy(&snapshot, ringBuffer) 7635 return out, metadata, &smithy.DeserializationError{ 7636 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7637 Snapshot: snapshot.Bytes(), 7638 } 7639 } 7640 7641 return out, metadata, err 7642} 7643 7644func awsRestjson1_deserializeOpErrorListVersionsByFunction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7645 var errorBuffer bytes.Buffer 7646 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7647 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7648 } 7649 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7650 7651 errorCode := "UnknownError" 7652 errorMessage := errorCode 7653 7654 code := response.Header.Get("X-Amzn-ErrorType") 7655 if len(code) != 0 { 7656 errorCode = restjson.SanitizeErrorCode(code) 7657 } 7658 7659 var buff [1024]byte 7660 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7661 7662 body := io.TeeReader(errorBody, ringBuffer) 7663 decoder := json.NewDecoder(body) 7664 decoder.UseNumber() 7665 code, message, err := restjson.GetErrorInfo(decoder) 7666 if err != nil { 7667 var snapshot bytes.Buffer 7668 io.Copy(&snapshot, ringBuffer) 7669 err = &smithy.DeserializationError{ 7670 Err: fmt.Errorf("failed to decode response body, %w", err), 7671 Snapshot: snapshot.Bytes(), 7672 } 7673 return err 7674 } 7675 7676 errorBody.Seek(0, io.SeekStart) 7677 if len(code) != 0 { 7678 errorCode = restjson.SanitizeErrorCode(code) 7679 } 7680 if len(message) != 0 { 7681 errorMessage = message 7682 } 7683 7684 switch { 7685 case strings.EqualFold("InvalidParameterValueException", errorCode): 7686 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 7687 7688 case strings.EqualFold("ResourceNotFoundException", errorCode): 7689 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7690 7691 case strings.EqualFold("ServiceException", errorCode): 7692 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 7693 7694 case strings.EqualFold("TooManyRequestsException", errorCode): 7695 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 7696 7697 default: 7698 genericError := &smithy.GenericAPIError{ 7699 Code: errorCode, 7700 Message: errorMessage, 7701 } 7702 return genericError 7703 7704 } 7705} 7706 7707func awsRestjson1_deserializeOpDocumentListVersionsByFunctionOutput(v **ListVersionsByFunctionOutput, value interface{}) error { 7708 if v == nil { 7709 return fmt.Errorf("unexpected nil of type %T", v) 7710 } 7711 if value == nil { 7712 return nil 7713 } 7714 7715 shape, ok := value.(map[string]interface{}) 7716 if !ok { 7717 return fmt.Errorf("unexpected JSON type %v", value) 7718 } 7719 7720 var sv *ListVersionsByFunctionOutput 7721 if *v == nil { 7722 sv = &ListVersionsByFunctionOutput{} 7723 } else { 7724 sv = *v 7725 } 7726 7727 for key, value := range shape { 7728 switch key { 7729 case "NextMarker": 7730 if value != nil { 7731 jtv, ok := value.(string) 7732 if !ok { 7733 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7734 } 7735 sv.NextMarker = ptr.String(jtv) 7736 } 7737 7738 case "Versions": 7739 if err := awsRestjson1_deserializeDocumentFunctionList(&sv.Versions, value); err != nil { 7740 return err 7741 } 7742 7743 default: 7744 _, _ = key, value 7745 7746 } 7747 } 7748 *v = sv 7749 return nil 7750} 7751 7752type awsRestjson1_deserializeOpPublishLayerVersion struct { 7753} 7754 7755func (*awsRestjson1_deserializeOpPublishLayerVersion) ID() string { 7756 return "OperationDeserializer" 7757} 7758 7759func (m *awsRestjson1_deserializeOpPublishLayerVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7760 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7761) { 7762 out, metadata, err = next.HandleDeserialize(ctx, in) 7763 if err != nil { 7764 return out, metadata, err 7765 } 7766 7767 response, ok := out.RawResponse.(*smithyhttp.Response) 7768 if !ok { 7769 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7770 } 7771 7772 if response.StatusCode < 200 || response.StatusCode >= 300 { 7773 return out, metadata, awsRestjson1_deserializeOpErrorPublishLayerVersion(response, &metadata) 7774 } 7775 output := &PublishLayerVersionOutput{} 7776 out.Result = output 7777 7778 var buff [1024]byte 7779 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7780 7781 body := io.TeeReader(response.Body, ringBuffer) 7782 7783 decoder := json.NewDecoder(body) 7784 decoder.UseNumber() 7785 var shape interface{} 7786 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7787 var snapshot bytes.Buffer 7788 io.Copy(&snapshot, ringBuffer) 7789 err = &smithy.DeserializationError{ 7790 Err: fmt.Errorf("failed to decode response body, %w", err), 7791 Snapshot: snapshot.Bytes(), 7792 } 7793 return out, metadata, err 7794 } 7795 7796 err = awsRestjson1_deserializeOpDocumentPublishLayerVersionOutput(&output, shape) 7797 if err != nil { 7798 var snapshot bytes.Buffer 7799 io.Copy(&snapshot, ringBuffer) 7800 return out, metadata, &smithy.DeserializationError{ 7801 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7802 Snapshot: snapshot.Bytes(), 7803 } 7804 } 7805 7806 return out, metadata, err 7807} 7808 7809func awsRestjson1_deserializeOpErrorPublishLayerVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7810 var errorBuffer bytes.Buffer 7811 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7812 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7813 } 7814 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7815 7816 errorCode := "UnknownError" 7817 errorMessage := errorCode 7818 7819 code := response.Header.Get("X-Amzn-ErrorType") 7820 if len(code) != 0 { 7821 errorCode = restjson.SanitizeErrorCode(code) 7822 } 7823 7824 var buff [1024]byte 7825 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7826 7827 body := io.TeeReader(errorBody, ringBuffer) 7828 decoder := json.NewDecoder(body) 7829 decoder.UseNumber() 7830 code, message, err := restjson.GetErrorInfo(decoder) 7831 if err != nil { 7832 var snapshot bytes.Buffer 7833 io.Copy(&snapshot, ringBuffer) 7834 err = &smithy.DeserializationError{ 7835 Err: fmt.Errorf("failed to decode response body, %w", err), 7836 Snapshot: snapshot.Bytes(), 7837 } 7838 return err 7839 } 7840 7841 errorBody.Seek(0, io.SeekStart) 7842 if len(code) != 0 { 7843 errorCode = restjson.SanitizeErrorCode(code) 7844 } 7845 if len(message) != 0 { 7846 errorMessage = message 7847 } 7848 7849 switch { 7850 case strings.EqualFold("CodeStorageExceededException", errorCode): 7851 return awsRestjson1_deserializeErrorCodeStorageExceededException(response, errorBody) 7852 7853 case strings.EqualFold("InvalidParameterValueException", errorCode): 7854 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 7855 7856 case strings.EqualFold("ResourceNotFoundException", errorCode): 7857 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7858 7859 case strings.EqualFold("ServiceException", errorCode): 7860 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 7861 7862 case strings.EqualFold("TooManyRequestsException", errorCode): 7863 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 7864 7865 default: 7866 genericError := &smithy.GenericAPIError{ 7867 Code: errorCode, 7868 Message: errorMessage, 7869 } 7870 return genericError 7871 7872 } 7873} 7874 7875func awsRestjson1_deserializeOpDocumentPublishLayerVersionOutput(v **PublishLayerVersionOutput, value interface{}) error { 7876 if v == nil { 7877 return fmt.Errorf("unexpected nil of type %T", v) 7878 } 7879 if value == nil { 7880 return nil 7881 } 7882 7883 shape, ok := value.(map[string]interface{}) 7884 if !ok { 7885 return fmt.Errorf("unexpected JSON type %v", value) 7886 } 7887 7888 var sv *PublishLayerVersionOutput 7889 if *v == nil { 7890 sv = &PublishLayerVersionOutput{} 7891 } else { 7892 sv = *v 7893 } 7894 7895 for key, value := range shape { 7896 switch key { 7897 case "CompatibleRuntimes": 7898 if err := awsRestjson1_deserializeDocumentCompatibleRuntimes(&sv.CompatibleRuntimes, value); err != nil { 7899 return err 7900 } 7901 7902 case "Content": 7903 if err := awsRestjson1_deserializeDocumentLayerVersionContentOutput(&sv.Content, value); err != nil { 7904 return err 7905 } 7906 7907 case "CreatedDate": 7908 if value != nil { 7909 jtv, ok := value.(string) 7910 if !ok { 7911 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 7912 } 7913 sv.CreatedDate = ptr.String(jtv) 7914 } 7915 7916 case "Description": 7917 if value != nil { 7918 jtv, ok := value.(string) 7919 if !ok { 7920 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 7921 } 7922 sv.Description = ptr.String(jtv) 7923 } 7924 7925 case "LayerArn": 7926 if value != nil { 7927 jtv, ok := value.(string) 7928 if !ok { 7929 return fmt.Errorf("expected LayerArn to be of type string, got %T instead", value) 7930 } 7931 sv.LayerArn = ptr.String(jtv) 7932 } 7933 7934 case "LayerVersionArn": 7935 if value != nil { 7936 jtv, ok := value.(string) 7937 if !ok { 7938 return fmt.Errorf("expected LayerVersionArn to be of type string, got %T instead", value) 7939 } 7940 sv.LayerVersionArn = ptr.String(jtv) 7941 } 7942 7943 case "LicenseInfo": 7944 if value != nil { 7945 jtv, ok := value.(string) 7946 if !ok { 7947 return fmt.Errorf("expected LicenseInfo to be of type string, got %T instead", value) 7948 } 7949 sv.LicenseInfo = ptr.String(jtv) 7950 } 7951 7952 case "Version": 7953 if value != nil { 7954 jtv, ok := value.(json.Number) 7955 if !ok { 7956 return fmt.Errorf("expected LayerVersionNumber to be json.Number, got %T instead", value) 7957 } 7958 i64, err := jtv.Int64() 7959 if err != nil { 7960 return err 7961 } 7962 sv.Version = i64 7963 } 7964 7965 default: 7966 _, _ = key, value 7967 7968 } 7969 } 7970 *v = sv 7971 return nil 7972} 7973 7974type awsRestjson1_deserializeOpPublishVersion struct { 7975} 7976 7977func (*awsRestjson1_deserializeOpPublishVersion) ID() string { 7978 return "OperationDeserializer" 7979} 7980 7981func (m *awsRestjson1_deserializeOpPublishVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7982 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7983) { 7984 out, metadata, err = next.HandleDeserialize(ctx, in) 7985 if err != nil { 7986 return out, metadata, err 7987 } 7988 7989 response, ok := out.RawResponse.(*smithyhttp.Response) 7990 if !ok { 7991 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7992 } 7993 7994 if response.StatusCode < 200 || response.StatusCode >= 300 { 7995 return out, metadata, awsRestjson1_deserializeOpErrorPublishVersion(response, &metadata) 7996 } 7997 output := &PublishVersionOutput{} 7998 out.Result = output 7999 8000 var buff [1024]byte 8001 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8002 8003 body := io.TeeReader(response.Body, ringBuffer) 8004 8005 decoder := json.NewDecoder(body) 8006 decoder.UseNumber() 8007 var shape interface{} 8008 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8009 var snapshot bytes.Buffer 8010 io.Copy(&snapshot, ringBuffer) 8011 err = &smithy.DeserializationError{ 8012 Err: fmt.Errorf("failed to decode response body, %w", err), 8013 Snapshot: snapshot.Bytes(), 8014 } 8015 return out, metadata, err 8016 } 8017 8018 err = awsRestjson1_deserializeOpDocumentPublishVersionOutput(&output, shape) 8019 if err != nil { 8020 var snapshot bytes.Buffer 8021 io.Copy(&snapshot, ringBuffer) 8022 return out, metadata, &smithy.DeserializationError{ 8023 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8024 Snapshot: snapshot.Bytes(), 8025 } 8026 } 8027 8028 return out, metadata, err 8029} 8030 8031func awsRestjson1_deserializeOpErrorPublishVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8032 var errorBuffer bytes.Buffer 8033 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8034 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8035 } 8036 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8037 8038 errorCode := "UnknownError" 8039 errorMessage := errorCode 8040 8041 code := response.Header.Get("X-Amzn-ErrorType") 8042 if len(code) != 0 { 8043 errorCode = restjson.SanitizeErrorCode(code) 8044 } 8045 8046 var buff [1024]byte 8047 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8048 8049 body := io.TeeReader(errorBody, ringBuffer) 8050 decoder := json.NewDecoder(body) 8051 decoder.UseNumber() 8052 code, message, err := restjson.GetErrorInfo(decoder) 8053 if err != nil { 8054 var snapshot bytes.Buffer 8055 io.Copy(&snapshot, ringBuffer) 8056 err = &smithy.DeserializationError{ 8057 Err: fmt.Errorf("failed to decode response body, %w", err), 8058 Snapshot: snapshot.Bytes(), 8059 } 8060 return err 8061 } 8062 8063 errorBody.Seek(0, io.SeekStart) 8064 if len(code) != 0 { 8065 errorCode = restjson.SanitizeErrorCode(code) 8066 } 8067 if len(message) != 0 { 8068 errorMessage = message 8069 } 8070 8071 switch { 8072 case strings.EqualFold("CodeStorageExceededException", errorCode): 8073 return awsRestjson1_deserializeErrorCodeStorageExceededException(response, errorBody) 8074 8075 case strings.EqualFold("InvalidParameterValueException", errorCode): 8076 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 8077 8078 case strings.EqualFold("PreconditionFailedException", errorCode): 8079 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 8080 8081 case strings.EqualFold("ResourceConflictException", errorCode): 8082 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 8083 8084 case strings.EqualFold("ResourceNotFoundException", errorCode): 8085 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8086 8087 case strings.EqualFold("ServiceException", errorCode): 8088 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 8089 8090 case strings.EqualFold("TooManyRequestsException", errorCode): 8091 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 8092 8093 default: 8094 genericError := &smithy.GenericAPIError{ 8095 Code: errorCode, 8096 Message: errorMessage, 8097 } 8098 return genericError 8099 8100 } 8101} 8102 8103func awsRestjson1_deserializeOpDocumentPublishVersionOutput(v **PublishVersionOutput, value interface{}) error { 8104 if v == nil { 8105 return fmt.Errorf("unexpected nil of type %T", v) 8106 } 8107 if value == nil { 8108 return nil 8109 } 8110 8111 shape, ok := value.(map[string]interface{}) 8112 if !ok { 8113 return fmt.Errorf("unexpected JSON type %v", value) 8114 } 8115 8116 var sv *PublishVersionOutput 8117 if *v == nil { 8118 sv = &PublishVersionOutput{} 8119 } else { 8120 sv = *v 8121 } 8122 8123 for key, value := range shape { 8124 switch key { 8125 case "CodeSha256": 8126 if value != nil { 8127 jtv, ok := value.(string) 8128 if !ok { 8129 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8130 } 8131 sv.CodeSha256 = ptr.String(jtv) 8132 } 8133 8134 case "CodeSize": 8135 if value != nil { 8136 jtv, ok := value.(json.Number) 8137 if !ok { 8138 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 8139 } 8140 i64, err := jtv.Int64() 8141 if err != nil { 8142 return err 8143 } 8144 sv.CodeSize = i64 8145 } 8146 8147 case "DeadLetterConfig": 8148 if err := awsRestjson1_deserializeDocumentDeadLetterConfig(&sv.DeadLetterConfig, value); err != nil { 8149 return err 8150 } 8151 8152 case "Description": 8153 if value != nil { 8154 jtv, ok := value.(string) 8155 if !ok { 8156 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 8157 } 8158 sv.Description = ptr.String(jtv) 8159 } 8160 8161 case "Environment": 8162 if err := awsRestjson1_deserializeDocumentEnvironmentResponse(&sv.Environment, value); err != nil { 8163 return err 8164 } 8165 8166 case "FileSystemConfigs": 8167 if err := awsRestjson1_deserializeDocumentFileSystemConfigList(&sv.FileSystemConfigs, value); err != nil { 8168 return err 8169 } 8170 8171 case "FunctionArn": 8172 if value != nil { 8173 jtv, ok := value.(string) 8174 if !ok { 8175 return fmt.Errorf("expected NameSpacedFunctionArn to be of type string, got %T instead", value) 8176 } 8177 sv.FunctionArn = ptr.String(jtv) 8178 } 8179 8180 case "FunctionName": 8181 if value != nil { 8182 jtv, ok := value.(string) 8183 if !ok { 8184 return fmt.Errorf("expected NamespacedFunctionName to be of type string, got %T instead", value) 8185 } 8186 sv.FunctionName = ptr.String(jtv) 8187 } 8188 8189 case "Handler": 8190 if value != nil { 8191 jtv, ok := value.(string) 8192 if !ok { 8193 return fmt.Errorf("expected Handler to be of type string, got %T instead", value) 8194 } 8195 sv.Handler = ptr.String(jtv) 8196 } 8197 8198 case "ImageConfigResponse": 8199 if err := awsRestjson1_deserializeDocumentImageConfigResponse(&sv.ImageConfigResponse, value); err != nil { 8200 return err 8201 } 8202 8203 case "KMSKeyArn": 8204 if value != nil { 8205 jtv, ok := value.(string) 8206 if !ok { 8207 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 8208 } 8209 sv.KMSKeyArn = ptr.String(jtv) 8210 } 8211 8212 case "LastModified": 8213 if value != nil { 8214 jtv, ok := value.(string) 8215 if !ok { 8216 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 8217 } 8218 sv.LastModified = ptr.String(jtv) 8219 } 8220 8221 case "LastUpdateStatus": 8222 if value != nil { 8223 jtv, ok := value.(string) 8224 if !ok { 8225 return fmt.Errorf("expected LastUpdateStatus to be of type string, got %T instead", value) 8226 } 8227 sv.LastUpdateStatus = types.LastUpdateStatus(jtv) 8228 } 8229 8230 case "LastUpdateStatusReason": 8231 if value != nil { 8232 jtv, ok := value.(string) 8233 if !ok { 8234 return fmt.Errorf("expected LastUpdateStatusReason to be of type string, got %T instead", value) 8235 } 8236 sv.LastUpdateStatusReason = ptr.String(jtv) 8237 } 8238 8239 case "LastUpdateStatusReasonCode": 8240 if value != nil { 8241 jtv, ok := value.(string) 8242 if !ok { 8243 return fmt.Errorf("expected LastUpdateStatusReasonCode to be of type string, got %T instead", value) 8244 } 8245 sv.LastUpdateStatusReasonCode = types.LastUpdateStatusReasonCode(jtv) 8246 } 8247 8248 case "Layers": 8249 if err := awsRestjson1_deserializeDocumentLayersReferenceList(&sv.Layers, value); err != nil { 8250 return err 8251 } 8252 8253 case "MasterArn": 8254 if value != nil { 8255 jtv, ok := value.(string) 8256 if !ok { 8257 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 8258 } 8259 sv.MasterArn = ptr.String(jtv) 8260 } 8261 8262 case "MemorySize": 8263 if value != nil { 8264 jtv, ok := value.(json.Number) 8265 if !ok { 8266 return fmt.Errorf("expected MemorySize to be json.Number, got %T instead", value) 8267 } 8268 i64, err := jtv.Int64() 8269 if err != nil { 8270 return err 8271 } 8272 sv.MemorySize = ptr.Int32(int32(i64)) 8273 } 8274 8275 case "PackageType": 8276 if value != nil { 8277 jtv, ok := value.(string) 8278 if !ok { 8279 return fmt.Errorf("expected PackageType to be of type string, got %T instead", value) 8280 } 8281 sv.PackageType = types.PackageType(jtv) 8282 } 8283 8284 case "RevisionId": 8285 if value != nil { 8286 jtv, ok := value.(string) 8287 if !ok { 8288 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8289 } 8290 sv.RevisionId = ptr.String(jtv) 8291 } 8292 8293 case "Role": 8294 if value != nil { 8295 jtv, ok := value.(string) 8296 if !ok { 8297 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 8298 } 8299 sv.Role = ptr.String(jtv) 8300 } 8301 8302 case "Runtime": 8303 if value != nil { 8304 jtv, ok := value.(string) 8305 if !ok { 8306 return fmt.Errorf("expected Runtime to be of type string, got %T instead", value) 8307 } 8308 sv.Runtime = types.Runtime(jtv) 8309 } 8310 8311 case "SigningJobArn": 8312 if value != nil { 8313 jtv, ok := value.(string) 8314 if !ok { 8315 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8316 } 8317 sv.SigningJobArn = ptr.String(jtv) 8318 } 8319 8320 case "SigningProfileVersionArn": 8321 if value != nil { 8322 jtv, ok := value.(string) 8323 if !ok { 8324 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8325 } 8326 sv.SigningProfileVersionArn = ptr.String(jtv) 8327 } 8328 8329 case "State": 8330 if value != nil { 8331 jtv, ok := value.(string) 8332 if !ok { 8333 return fmt.Errorf("expected State to be of type string, got %T instead", value) 8334 } 8335 sv.State = types.State(jtv) 8336 } 8337 8338 case "StateReason": 8339 if value != nil { 8340 jtv, ok := value.(string) 8341 if !ok { 8342 return fmt.Errorf("expected StateReason to be of type string, got %T instead", value) 8343 } 8344 sv.StateReason = ptr.String(jtv) 8345 } 8346 8347 case "StateReasonCode": 8348 if value != nil { 8349 jtv, ok := value.(string) 8350 if !ok { 8351 return fmt.Errorf("expected StateReasonCode to be of type string, got %T instead", value) 8352 } 8353 sv.StateReasonCode = types.StateReasonCode(jtv) 8354 } 8355 8356 case "Timeout": 8357 if value != nil { 8358 jtv, ok := value.(json.Number) 8359 if !ok { 8360 return fmt.Errorf("expected Timeout to be json.Number, got %T instead", value) 8361 } 8362 i64, err := jtv.Int64() 8363 if err != nil { 8364 return err 8365 } 8366 sv.Timeout = ptr.Int32(int32(i64)) 8367 } 8368 8369 case "TracingConfig": 8370 if err := awsRestjson1_deserializeDocumentTracingConfigResponse(&sv.TracingConfig, value); err != nil { 8371 return err 8372 } 8373 8374 case "Version": 8375 if value != nil { 8376 jtv, ok := value.(string) 8377 if !ok { 8378 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 8379 } 8380 sv.Version = ptr.String(jtv) 8381 } 8382 8383 case "VpcConfig": 8384 if err := awsRestjson1_deserializeDocumentVpcConfigResponse(&sv.VpcConfig, value); err != nil { 8385 return err 8386 } 8387 8388 default: 8389 _, _ = key, value 8390 8391 } 8392 } 8393 *v = sv 8394 return nil 8395} 8396 8397type awsRestjson1_deserializeOpPutFunctionCodeSigningConfig struct { 8398} 8399 8400func (*awsRestjson1_deserializeOpPutFunctionCodeSigningConfig) ID() string { 8401 return "OperationDeserializer" 8402} 8403 8404func (m *awsRestjson1_deserializeOpPutFunctionCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8405 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8406) { 8407 out, metadata, err = next.HandleDeserialize(ctx, in) 8408 if err != nil { 8409 return out, metadata, err 8410 } 8411 8412 response, ok := out.RawResponse.(*smithyhttp.Response) 8413 if !ok { 8414 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8415 } 8416 8417 if response.StatusCode < 200 || response.StatusCode >= 300 { 8418 return out, metadata, awsRestjson1_deserializeOpErrorPutFunctionCodeSigningConfig(response, &metadata) 8419 } 8420 output := &PutFunctionCodeSigningConfigOutput{} 8421 out.Result = output 8422 8423 var buff [1024]byte 8424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8425 8426 body := io.TeeReader(response.Body, ringBuffer) 8427 8428 decoder := json.NewDecoder(body) 8429 decoder.UseNumber() 8430 var shape interface{} 8431 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8432 var snapshot bytes.Buffer 8433 io.Copy(&snapshot, ringBuffer) 8434 err = &smithy.DeserializationError{ 8435 Err: fmt.Errorf("failed to decode response body, %w", err), 8436 Snapshot: snapshot.Bytes(), 8437 } 8438 return out, metadata, err 8439 } 8440 8441 err = awsRestjson1_deserializeOpDocumentPutFunctionCodeSigningConfigOutput(&output, shape) 8442 if err != nil { 8443 var snapshot bytes.Buffer 8444 io.Copy(&snapshot, ringBuffer) 8445 return out, metadata, &smithy.DeserializationError{ 8446 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8447 Snapshot: snapshot.Bytes(), 8448 } 8449 } 8450 8451 return out, metadata, err 8452} 8453 8454func awsRestjson1_deserializeOpErrorPutFunctionCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8455 var errorBuffer bytes.Buffer 8456 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8457 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8458 } 8459 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8460 8461 errorCode := "UnknownError" 8462 errorMessage := errorCode 8463 8464 code := response.Header.Get("X-Amzn-ErrorType") 8465 if len(code) != 0 { 8466 errorCode = restjson.SanitizeErrorCode(code) 8467 } 8468 8469 var buff [1024]byte 8470 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8471 8472 body := io.TeeReader(errorBody, ringBuffer) 8473 decoder := json.NewDecoder(body) 8474 decoder.UseNumber() 8475 code, message, err := restjson.GetErrorInfo(decoder) 8476 if err != nil { 8477 var snapshot bytes.Buffer 8478 io.Copy(&snapshot, ringBuffer) 8479 err = &smithy.DeserializationError{ 8480 Err: fmt.Errorf("failed to decode response body, %w", err), 8481 Snapshot: snapshot.Bytes(), 8482 } 8483 return err 8484 } 8485 8486 errorBody.Seek(0, io.SeekStart) 8487 if len(code) != 0 { 8488 errorCode = restjson.SanitizeErrorCode(code) 8489 } 8490 if len(message) != 0 { 8491 errorMessage = message 8492 } 8493 8494 switch { 8495 case strings.EqualFold("CodeSigningConfigNotFoundException", errorCode): 8496 return awsRestjson1_deserializeErrorCodeSigningConfigNotFoundException(response, errorBody) 8497 8498 case strings.EqualFold("InvalidParameterValueException", errorCode): 8499 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 8500 8501 case strings.EqualFold("ResourceConflictException", errorCode): 8502 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 8503 8504 case strings.EqualFold("ResourceNotFoundException", errorCode): 8505 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8506 8507 case strings.EqualFold("ServiceException", errorCode): 8508 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 8509 8510 case strings.EqualFold("TooManyRequestsException", errorCode): 8511 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 8512 8513 default: 8514 genericError := &smithy.GenericAPIError{ 8515 Code: errorCode, 8516 Message: errorMessage, 8517 } 8518 return genericError 8519 8520 } 8521} 8522 8523func awsRestjson1_deserializeOpDocumentPutFunctionCodeSigningConfigOutput(v **PutFunctionCodeSigningConfigOutput, value interface{}) error { 8524 if v == nil { 8525 return fmt.Errorf("unexpected nil of type %T", v) 8526 } 8527 if value == nil { 8528 return nil 8529 } 8530 8531 shape, ok := value.(map[string]interface{}) 8532 if !ok { 8533 return fmt.Errorf("unexpected JSON type %v", value) 8534 } 8535 8536 var sv *PutFunctionCodeSigningConfigOutput 8537 if *v == nil { 8538 sv = &PutFunctionCodeSigningConfigOutput{} 8539 } else { 8540 sv = *v 8541 } 8542 8543 for key, value := range shape { 8544 switch key { 8545 case "CodeSigningConfigArn": 8546 if value != nil { 8547 jtv, ok := value.(string) 8548 if !ok { 8549 return fmt.Errorf("expected CodeSigningConfigArn to be of type string, got %T instead", value) 8550 } 8551 sv.CodeSigningConfigArn = ptr.String(jtv) 8552 } 8553 8554 case "FunctionName": 8555 if value != nil { 8556 jtv, ok := value.(string) 8557 if !ok { 8558 return fmt.Errorf("expected FunctionName to be of type string, got %T instead", value) 8559 } 8560 sv.FunctionName = ptr.String(jtv) 8561 } 8562 8563 default: 8564 _, _ = key, value 8565 8566 } 8567 } 8568 *v = sv 8569 return nil 8570} 8571 8572type awsRestjson1_deserializeOpPutFunctionConcurrency struct { 8573} 8574 8575func (*awsRestjson1_deserializeOpPutFunctionConcurrency) ID() string { 8576 return "OperationDeserializer" 8577} 8578 8579func (m *awsRestjson1_deserializeOpPutFunctionConcurrency) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8580 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8581) { 8582 out, metadata, err = next.HandleDeserialize(ctx, in) 8583 if err != nil { 8584 return out, metadata, err 8585 } 8586 8587 response, ok := out.RawResponse.(*smithyhttp.Response) 8588 if !ok { 8589 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8590 } 8591 8592 if response.StatusCode < 200 || response.StatusCode >= 300 { 8593 return out, metadata, awsRestjson1_deserializeOpErrorPutFunctionConcurrency(response, &metadata) 8594 } 8595 output := &PutFunctionConcurrencyOutput{} 8596 out.Result = output 8597 8598 var buff [1024]byte 8599 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8600 8601 body := io.TeeReader(response.Body, ringBuffer) 8602 8603 decoder := json.NewDecoder(body) 8604 decoder.UseNumber() 8605 var shape interface{} 8606 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8607 var snapshot bytes.Buffer 8608 io.Copy(&snapshot, ringBuffer) 8609 err = &smithy.DeserializationError{ 8610 Err: fmt.Errorf("failed to decode response body, %w", err), 8611 Snapshot: snapshot.Bytes(), 8612 } 8613 return out, metadata, err 8614 } 8615 8616 err = awsRestjson1_deserializeOpDocumentPutFunctionConcurrencyOutput(&output, shape) 8617 if err != nil { 8618 var snapshot bytes.Buffer 8619 io.Copy(&snapshot, ringBuffer) 8620 return out, metadata, &smithy.DeserializationError{ 8621 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8622 Snapshot: snapshot.Bytes(), 8623 } 8624 } 8625 8626 return out, metadata, err 8627} 8628 8629func awsRestjson1_deserializeOpErrorPutFunctionConcurrency(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8630 var errorBuffer bytes.Buffer 8631 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8632 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8633 } 8634 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8635 8636 errorCode := "UnknownError" 8637 errorMessage := errorCode 8638 8639 code := response.Header.Get("X-Amzn-ErrorType") 8640 if len(code) != 0 { 8641 errorCode = restjson.SanitizeErrorCode(code) 8642 } 8643 8644 var buff [1024]byte 8645 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8646 8647 body := io.TeeReader(errorBody, ringBuffer) 8648 decoder := json.NewDecoder(body) 8649 decoder.UseNumber() 8650 code, message, err := restjson.GetErrorInfo(decoder) 8651 if err != nil { 8652 var snapshot bytes.Buffer 8653 io.Copy(&snapshot, ringBuffer) 8654 err = &smithy.DeserializationError{ 8655 Err: fmt.Errorf("failed to decode response body, %w", err), 8656 Snapshot: snapshot.Bytes(), 8657 } 8658 return err 8659 } 8660 8661 errorBody.Seek(0, io.SeekStart) 8662 if len(code) != 0 { 8663 errorCode = restjson.SanitizeErrorCode(code) 8664 } 8665 if len(message) != 0 { 8666 errorMessage = message 8667 } 8668 8669 switch { 8670 case strings.EqualFold("InvalidParameterValueException", errorCode): 8671 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 8672 8673 case strings.EqualFold("ResourceConflictException", errorCode): 8674 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 8675 8676 case strings.EqualFold("ResourceNotFoundException", errorCode): 8677 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8678 8679 case strings.EqualFold("ServiceException", errorCode): 8680 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 8681 8682 case strings.EqualFold("TooManyRequestsException", errorCode): 8683 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 8684 8685 default: 8686 genericError := &smithy.GenericAPIError{ 8687 Code: errorCode, 8688 Message: errorMessage, 8689 } 8690 return genericError 8691 8692 } 8693} 8694 8695func awsRestjson1_deserializeOpDocumentPutFunctionConcurrencyOutput(v **PutFunctionConcurrencyOutput, value interface{}) error { 8696 if v == nil { 8697 return fmt.Errorf("unexpected nil of type %T", v) 8698 } 8699 if value == nil { 8700 return nil 8701 } 8702 8703 shape, ok := value.(map[string]interface{}) 8704 if !ok { 8705 return fmt.Errorf("unexpected JSON type %v", value) 8706 } 8707 8708 var sv *PutFunctionConcurrencyOutput 8709 if *v == nil { 8710 sv = &PutFunctionConcurrencyOutput{} 8711 } else { 8712 sv = *v 8713 } 8714 8715 for key, value := range shape { 8716 switch key { 8717 case "ReservedConcurrentExecutions": 8718 if value != nil { 8719 jtv, ok := value.(json.Number) 8720 if !ok { 8721 return fmt.Errorf("expected ReservedConcurrentExecutions to be json.Number, got %T instead", value) 8722 } 8723 i64, err := jtv.Int64() 8724 if err != nil { 8725 return err 8726 } 8727 sv.ReservedConcurrentExecutions = ptr.Int32(int32(i64)) 8728 } 8729 8730 default: 8731 _, _ = key, value 8732 8733 } 8734 } 8735 *v = sv 8736 return nil 8737} 8738 8739type awsRestjson1_deserializeOpPutFunctionEventInvokeConfig struct { 8740} 8741 8742func (*awsRestjson1_deserializeOpPutFunctionEventInvokeConfig) ID() string { 8743 return "OperationDeserializer" 8744} 8745 8746func (m *awsRestjson1_deserializeOpPutFunctionEventInvokeConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8747 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8748) { 8749 out, metadata, err = next.HandleDeserialize(ctx, in) 8750 if err != nil { 8751 return out, metadata, err 8752 } 8753 8754 response, ok := out.RawResponse.(*smithyhttp.Response) 8755 if !ok { 8756 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8757 } 8758 8759 if response.StatusCode < 200 || response.StatusCode >= 300 { 8760 return out, metadata, awsRestjson1_deserializeOpErrorPutFunctionEventInvokeConfig(response, &metadata) 8761 } 8762 output := &PutFunctionEventInvokeConfigOutput{} 8763 out.Result = output 8764 8765 var buff [1024]byte 8766 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8767 8768 body := io.TeeReader(response.Body, ringBuffer) 8769 8770 decoder := json.NewDecoder(body) 8771 decoder.UseNumber() 8772 var shape interface{} 8773 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8774 var snapshot bytes.Buffer 8775 io.Copy(&snapshot, ringBuffer) 8776 err = &smithy.DeserializationError{ 8777 Err: fmt.Errorf("failed to decode response body, %w", err), 8778 Snapshot: snapshot.Bytes(), 8779 } 8780 return out, metadata, err 8781 } 8782 8783 err = awsRestjson1_deserializeOpDocumentPutFunctionEventInvokeConfigOutput(&output, shape) 8784 if err != nil { 8785 var snapshot bytes.Buffer 8786 io.Copy(&snapshot, ringBuffer) 8787 return out, metadata, &smithy.DeserializationError{ 8788 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8789 Snapshot: snapshot.Bytes(), 8790 } 8791 } 8792 8793 return out, metadata, err 8794} 8795 8796func awsRestjson1_deserializeOpErrorPutFunctionEventInvokeConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8797 var errorBuffer bytes.Buffer 8798 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8799 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8800 } 8801 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8802 8803 errorCode := "UnknownError" 8804 errorMessage := errorCode 8805 8806 code := response.Header.Get("X-Amzn-ErrorType") 8807 if len(code) != 0 { 8808 errorCode = restjson.SanitizeErrorCode(code) 8809 } 8810 8811 var buff [1024]byte 8812 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8813 8814 body := io.TeeReader(errorBody, ringBuffer) 8815 decoder := json.NewDecoder(body) 8816 decoder.UseNumber() 8817 code, message, err := restjson.GetErrorInfo(decoder) 8818 if err != nil { 8819 var snapshot bytes.Buffer 8820 io.Copy(&snapshot, ringBuffer) 8821 err = &smithy.DeserializationError{ 8822 Err: fmt.Errorf("failed to decode response body, %w", err), 8823 Snapshot: snapshot.Bytes(), 8824 } 8825 return err 8826 } 8827 8828 errorBody.Seek(0, io.SeekStart) 8829 if len(code) != 0 { 8830 errorCode = restjson.SanitizeErrorCode(code) 8831 } 8832 if len(message) != 0 { 8833 errorMessage = message 8834 } 8835 8836 switch { 8837 case strings.EqualFold("InvalidParameterValueException", errorCode): 8838 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 8839 8840 case strings.EqualFold("ResourceNotFoundException", errorCode): 8841 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8842 8843 case strings.EqualFold("ServiceException", errorCode): 8844 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 8845 8846 case strings.EqualFold("TooManyRequestsException", errorCode): 8847 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 8848 8849 default: 8850 genericError := &smithy.GenericAPIError{ 8851 Code: errorCode, 8852 Message: errorMessage, 8853 } 8854 return genericError 8855 8856 } 8857} 8858 8859func awsRestjson1_deserializeOpDocumentPutFunctionEventInvokeConfigOutput(v **PutFunctionEventInvokeConfigOutput, value interface{}) error { 8860 if v == nil { 8861 return fmt.Errorf("unexpected nil of type %T", v) 8862 } 8863 if value == nil { 8864 return nil 8865 } 8866 8867 shape, ok := value.(map[string]interface{}) 8868 if !ok { 8869 return fmt.Errorf("unexpected JSON type %v", value) 8870 } 8871 8872 var sv *PutFunctionEventInvokeConfigOutput 8873 if *v == nil { 8874 sv = &PutFunctionEventInvokeConfigOutput{} 8875 } else { 8876 sv = *v 8877 } 8878 8879 for key, value := range shape { 8880 switch key { 8881 case "DestinationConfig": 8882 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 8883 return err 8884 } 8885 8886 case "FunctionArn": 8887 if value != nil { 8888 jtv, ok := value.(string) 8889 if !ok { 8890 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 8891 } 8892 sv.FunctionArn = ptr.String(jtv) 8893 } 8894 8895 case "LastModified": 8896 if value != nil { 8897 jtv, ok := value.(json.Number) 8898 if !ok { 8899 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 8900 } 8901 f64, err := jtv.Float64() 8902 if err != nil { 8903 return err 8904 } 8905 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8906 } 8907 8908 case "MaximumEventAgeInSeconds": 8909 if value != nil { 8910 jtv, ok := value.(json.Number) 8911 if !ok { 8912 return fmt.Errorf("expected MaximumEventAgeInSeconds to be json.Number, got %T instead", value) 8913 } 8914 i64, err := jtv.Int64() 8915 if err != nil { 8916 return err 8917 } 8918 sv.MaximumEventAgeInSeconds = ptr.Int32(int32(i64)) 8919 } 8920 8921 case "MaximumRetryAttempts": 8922 if value != nil { 8923 jtv, ok := value.(json.Number) 8924 if !ok { 8925 return fmt.Errorf("expected MaximumRetryAttempts to be json.Number, got %T instead", value) 8926 } 8927 i64, err := jtv.Int64() 8928 if err != nil { 8929 return err 8930 } 8931 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 8932 } 8933 8934 default: 8935 _, _ = key, value 8936 8937 } 8938 } 8939 *v = sv 8940 return nil 8941} 8942 8943type awsRestjson1_deserializeOpPutProvisionedConcurrencyConfig struct { 8944} 8945 8946func (*awsRestjson1_deserializeOpPutProvisionedConcurrencyConfig) ID() string { 8947 return "OperationDeserializer" 8948} 8949 8950func (m *awsRestjson1_deserializeOpPutProvisionedConcurrencyConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8951 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8952) { 8953 out, metadata, err = next.HandleDeserialize(ctx, in) 8954 if err != nil { 8955 return out, metadata, err 8956 } 8957 8958 response, ok := out.RawResponse.(*smithyhttp.Response) 8959 if !ok { 8960 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8961 } 8962 8963 if response.StatusCode < 200 || response.StatusCode >= 300 { 8964 return out, metadata, awsRestjson1_deserializeOpErrorPutProvisionedConcurrencyConfig(response, &metadata) 8965 } 8966 output := &PutProvisionedConcurrencyConfigOutput{} 8967 out.Result = output 8968 8969 var buff [1024]byte 8970 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8971 8972 body := io.TeeReader(response.Body, ringBuffer) 8973 8974 decoder := json.NewDecoder(body) 8975 decoder.UseNumber() 8976 var shape interface{} 8977 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8978 var snapshot bytes.Buffer 8979 io.Copy(&snapshot, ringBuffer) 8980 err = &smithy.DeserializationError{ 8981 Err: fmt.Errorf("failed to decode response body, %w", err), 8982 Snapshot: snapshot.Bytes(), 8983 } 8984 return out, metadata, err 8985 } 8986 8987 err = awsRestjson1_deserializeOpDocumentPutProvisionedConcurrencyConfigOutput(&output, shape) 8988 if err != nil { 8989 var snapshot bytes.Buffer 8990 io.Copy(&snapshot, ringBuffer) 8991 return out, metadata, &smithy.DeserializationError{ 8992 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8993 Snapshot: snapshot.Bytes(), 8994 } 8995 } 8996 8997 return out, metadata, err 8998} 8999 9000func awsRestjson1_deserializeOpErrorPutProvisionedConcurrencyConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9001 var errorBuffer bytes.Buffer 9002 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9003 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9004 } 9005 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9006 9007 errorCode := "UnknownError" 9008 errorMessage := errorCode 9009 9010 code := response.Header.Get("X-Amzn-ErrorType") 9011 if len(code) != 0 { 9012 errorCode = restjson.SanitizeErrorCode(code) 9013 } 9014 9015 var buff [1024]byte 9016 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9017 9018 body := io.TeeReader(errorBody, ringBuffer) 9019 decoder := json.NewDecoder(body) 9020 decoder.UseNumber() 9021 code, message, err := restjson.GetErrorInfo(decoder) 9022 if err != nil { 9023 var snapshot bytes.Buffer 9024 io.Copy(&snapshot, ringBuffer) 9025 err = &smithy.DeserializationError{ 9026 Err: fmt.Errorf("failed to decode response body, %w", err), 9027 Snapshot: snapshot.Bytes(), 9028 } 9029 return err 9030 } 9031 9032 errorBody.Seek(0, io.SeekStart) 9033 if len(code) != 0 { 9034 errorCode = restjson.SanitizeErrorCode(code) 9035 } 9036 if len(message) != 0 { 9037 errorMessage = message 9038 } 9039 9040 switch { 9041 case strings.EqualFold("InvalidParameterValueException", errorCode): 9042 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 9043 9044 case strings.EqualFold("ResourceConflictException", errorCode): 9045 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 9046 9047 case strings.EqualFold("ResourceNotFoundException", errorCode): 9048 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9049 9050 case strings.EqualFold("ServiceException", errorCode): 9051 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 9052 9053 case strings.EqualFold("TooManyRequestsException", errorCode): 9054 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 9055 9056 default: 9057 genericError := &smithy.GenericAPIError{ 9058 Code: errorCode, 9059 Message: errorMessage, 9060 } 9061 return genericError 9062 9063 } 9064} 9065 9066func awsRestjson1_deserializeOpDocumentPutProvisionedConcurrencyConfigOutput(v **PutProvisionedConcurrencyConfigOutput, value interface{}) error { 9067 if v == nil { 9068 return fmt.Errorf("unexpected nil of type %T", v) 9069 } 9070 if value == nil { 9071 return nil 9072 } 9073 9074 shape, ok := value.(map[string]interface{}) 9075 if !ok { 9076 return fmt.Errorf("unexpected JSON type %v", value) 9077 } 9078 9079 var sv *PutProvisionedConcurrencyConfigOutput 9080 if *v == nil { 9081 sv = &PutProvisionedConcurrencyConfigOutput{} 9082 } else { 9083 sv = *v 9084 } 9085 9086 for key, value := range shape { 9087 switch key { 9088 case "AllocatedProvisionedConcurrentExecutions": 9089 if value != nil { 9090 jtv, ok := value.(json.Number) 9091 if !ok { 9092 return fmt.Errorf("expected NonNegativeInteger to be json.Number, got %T instead", value) 9093 } 9094 i64, err := jtv.Int64() 9095 if err != nil { 9096 return err 9097 } 9098 sv.AllocatedProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 9099 } 9100 9101 case "AvailableProvisionedConcurrentExecutions": 9102 if value != nil { 9103 jtv, ok := value.(json.Number) 9104 if !ok { 9105 return fmt.Errorf("expected NonNegativeInteger to be json.Number, got %T instead", value) 9106 } 9107 i64, err := jtv.Int64() 9108 if err != nil { 9109 return err 9110 } 9111 sv.AvailableProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 9112 } 9113 9114 case "LastModified": 9115 if value != nil { 9116 jtv, ok := value.(string) 9117 if !ok { 9118 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 9119 } 9120 sv.LastModified = ptr.String(jtv) 9121 } 9122 9123 case "RequestedProvisionedConcurrentExecutions": 9124 if value != nil { 9125 jtv, ok := value.(json.Number) 9126 if !ok { 9127 return fmt.Errorf("expected PositiveInteger to be json.Number, got %T instead", value) 9128 } 9129 i64, err := jtv.Int64() 9130 if err != nil { 9131 return err 9132 } 9133 sv.RequestedProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 9134 } 9135 9136 case "Status": 9137 if value != nil { 9138 jtv, ok := value.(string) 9139 if !ok { 9140 return fmt.Errorf("expected ProvisionedConcurrencyStatusEnum to be of type string, got %T instead", value) 9141 } 9142 sv.Status = types.ProvisionedConcurrencyStatusEnum(jtv) 9143 } 9144 9145 case "StatusReason": 9146 if value != nil { 9147 jtv, ok := value.(string) 9148 if !ok { 9149 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9150 } 9151 sv.StatusReason = ptr.String(jtv) 9152 } 9153 9154 default: 9155 _, _ = key, value 9156 9157 } 9158 } 9159 *v = sv 9160 return nil 9161} 9162 9163type awsRestjson1_deserializeOpRemoveLayerVersionPermission struct { 9164} 9165 9166func (*awsRestjson1_deserializeOpRemoveLayerVersionPermission) ID() string { 9167 return "OperationDeserializer" 9168} 9169 9170func (m *awsRestjson1_deserializeOpRemoveLayerVersionPermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9171 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9172) { 9173 out, metadata, err = next.HandleDeserialize(ctx, in) 9174 if err != nil { 9175 return out, metadata, err 9176 } 9177 9178 response, ok := out.RawResponse.(*smithyhttp.Response) 9179 if !ok { 9180 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9181 } 9182 9183 if response.StatusCode < 200 || response.StatusCode >= 300 { 9184 return out, metadata, awsRestjson1_deserializeOpErrorRemoveLayerVersionPermission(response, &metadata) 9185 } 9186 output := &RemoveLayerVersionPermissionOutput{} 9187 out.Result = output 9188 9189 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9190 return out, metadata, &smithy.DeserializationError{ 9191 Err: fmt.Errorf("failed to discard response body, %w", err), 9192 } 9193 } 9194 9195 return out, metadata, err 9196} 9197 9198func awsRestjson1_deserializeOpErrorRemoveLayerVersionPermission(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9199 var errorBuffer bytes.Buffer 9200 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9201 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9202 } 9203 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9204 9205 errorCode := "UnknownError" 9206 errorMessage := errorCode 9207 9208 code := response.Header.Get("X-Amzn-ErrorType") 9209 if len(code) != 0 { 9210 errorCode = restjson.SanitizeErrorCode(code) 9211 } 9212 9213 var buff [1024]byte 9214 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9215 9216 body := io.TeeReader(errorBody, ringBuffer) 9217 decoder := json.NewDecoder(body) 9218 decoder.UseNumber() 9219 code, message, err := restjson.GetErrorInfo(decoder) 9220 if err != nil { 9221 var snapshot bytes.Buffer 9222 io.Copy(&snapshot, ringBuffer) 9223 err = &smithy.DeserializationError{ 9224 Err: fmt.Errorf("failed to decode response body, %w", err), 9225 Snapshot: snapshot.Bytes(), 9226 } 9227 return err 9228 } 9229 9230 errorBody.Seek(0, io.SeekStart) 9231 if len(code) != 0 { 9232 errorCode = restjson.SanitizeErrorCode(code) 9233 } 9234 if len(message) != 0 { 9235 errorMessage = message 9236 } 9237 9238 switch { 9239 case strings.EqualFold("InvalidParameterValueException", errorCode): 9240 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 9241 9242 case strings.EqualFold("PreconditionFailedException", errorCode): 9243 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 9244 9245 case strings.EqualFold("ResourceNotFoundException", errorCode): 9246 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9247 9248 case strings.EqualFold("ServiceException", errorCode): 9249 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 9250 9251 case strings.EqualFold("TooManyRequestsException", errorCode): 9252 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 9253 9254 default: 9255 genericError := &smithy.GenericAPIError{ 9256 Code: errorCode, 9257 Message: errorMessage, 9258 } 9259 return genericError 9260 9261 } 9262} 9263 9264type awsRestjson1_deserializeOpRemovePermission struct { 9265} 9266 9267func (*awsRestjson1_deserializeOpRemovePermission) ID() string { 9268 return "OperationDeserializer" 9269} 9270 9271func (m *awsRestjson1_deserializeOpRemovePermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9272 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9273) { 9274 out, metadata, err = next.HandleDeserialize(ctx, in) 9275 if err != nil { 9276 return out, metadata, err 9277 } 9278 9279 response, ok := out.RawResponse.(*smithyhttp.Response) 9280 if !ok { 9281 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9282 } 9283 9284 if response.StatusCode < 200 || response.StatusCode >= 300 { 9285 return out, metadata, awsRestjson1_deserializeOpErrorRemovePermission(response, &metadata) 9286 } 9287 output := &RemovePermissionOutput{} 9288 out.Result = output 9289 9290 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9291 return out, metadata, &smithy.DeserializationError{ 9292 Err: fmt.Errorf("failed to discard response body, %w", err), 9293 } 9294 } 9295 9296 return out, metadata, err 9297} 9298 9299func awsRestjson1_deserializeOpErrorRemovePermission(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9300 var errorBuffer bytes.Buffer 9301 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9302 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9303 } 9304 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9305 9306 errorCode := "UnknownError" 9307 errorMessage := errorCode 9308 9309 code := response.Header.Get("X-Amzn-ErrorType") 9310 if len(code) != 0 { 9311 errorCode = restjson.SanitizeErrorCode(code) 9312 } 9313 9314 var buff [1024]byte 9315 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9316 9317 body := io.TeeReader(errorBody, ringBuffer) 9318 decoder := json.NewDecoder(body) 9319 decoder.UseNumber() 9320 code, message, err := restjson.GetErrorInfo(decoder) 9321 if err != nil { 9322 var snapshot bytes.Buffer 9323 io.Copy(&snapshot, ringBuffer) 9324 err = &smithy.DeserializationError{ 9325 Err: fmt.Errorf("failed to decode response body, %w", err), 9326 Snapshot: snapshot.Bytes(), 9327 } 9328 return err 9329 } 9330 9331 errorBody.Seek(0, io.SeekStart) 9332 if len(code) != 0 { 9333 errorCode = restjson.SanitizeErrorCode(code) 9334 } 9335 if len(message) != 0 { 9336 errorMessage = message 9337 } 9338 9339 switch { 9340 case strings.EqualFold("InvalidParameterValueException", errorCode): 9341 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 9342 9343 case strings.EqualFold("PreconditionFailedException", errorCode): 9344 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 9345 9346 case strings.EqualFold("ResourceNotFoundException", errorCode): 9347 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9348 9349 case strings.EqualFold("ServiceException", errorCode): 9350 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 9351 9352 case strings.EqualFold("TooManyRequestsException", errorCode): 9353 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 9354 9355 default: 9356 genericError := &smithy.GenericAPIError{ 9357 Code: errorCode, 9358 Message: errorMessage, 9359 } 9360 return genericError 9361 9362 } 9363} 9364 9365type awsRestjson1_deserializeOpTagResource struct { 9366} 9367 9368func (*awsRestjson1_deserializeOpTagResource) ID() string { 9369 return "OperationDeserializer" 9370} 9371 9372func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9373 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9374) { 9375 out, metadata, err = next.HandleDeserialize(ctx, in) 9376 if err != nil { 9377 return out, metadata, err 9378 } 9379 9380 response, ok := out.RawResponse.(*smithyhttp.Response) 9381 if !ok { 9382 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9383 } 9384 9385 if response.StatusCode < 200 || response.StatusCode >= 300 { 9386 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 9387 } 9388 output := &TagResourceOutput{} 9389 out.Result = output 9390 9391 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9392 return out, metadata, &smithy.DeserializationError{ 9393 Err: fmt.Errorf("failed to discard response body, %w", err), 9394 } 9395 } 9396 9397 return out, metadata, err 9398} 9399 9400func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9401 var errorBuffer bytes.Buffer 9402 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9403 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9404 } 9405 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9406 9407 errorCode := "UnknownError" 9408 errorMessage := errorCode 9409 9410 code := response.Header.Get("X-Amzn-ErrorType") 9411 if len(code) != 0 { 9412 errorCode = restjson.SanitizeErrorCode(code) 9413 } 9414 9415 var buff [1024]byte 9416 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9417 9418 body := io.TeeReader(errorBody, ringBuffer) 9419 decoder := json.NewDecoder(body) 9420 decoder.UseNumber() 9421 code, message, err := restjson.GetErrorInfo(decoder) 9422 if err != nil { 9423 var snapshot bytes.Buffer 9424 io.Copy(&snapshot, ringBuffer) 9425 err = &smithy.DeserializationError{ 9426 Err: fmt.Errorf("failed to decode response body, %w", err), 9427 Snapshot: snapshot.Bytes(), 9428 } 9429 return err 9430 } 9431 9432 errorBody.Seek(0, io.SeekStart) 9433 if len(code) != 0 { 9434 errorCode = restjson.SanitizeErrorCode(code) 9435 } 9436 if len(message) != 0 { 9437 errorMessage = message 9438 } 9439 9440 switch { 9441 case strings.EqualFold("InvalidParameterValueException", errorCode): 9442 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 9443 9444 case strings.EqualFold("ResourceConflictException", errorCode): 9445 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 9446 9447 case strings.EqualFold("ResourceNotFoundException", errorCode): 9448 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9449 9450 case strings.EqualFold("ServiceException", errorCode): 9451 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 9452 9453 case strings.EqualFold("TooManyRequestsException", errorCode): 9454 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 9455 9456 default: 9457 genericError := &smithy.GenericAPIError{ 9458 Code: errorCode, 9459 Message: errorMessage, 9460 } 9461 return genericError 9462 9463 } 9464} 9465 9466type awsRestjson1_deserializeOpUntagResource struct { 9467} 9468 9469func (*awsRestjson1_deserializeOpUntagResource) ID() string { 9470 return "OperationDeserializer" 9471} 9472 9473func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9474 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9475) { 9476 out, metadata, err = next.HandleDeserialize(ctx, in) 9477 if err != nil { 9478 return out, metadata, err 9479 } 9480 9481 response, ok := out.RawResponse.(*smithyhttp.Response) 9482 if !ok { 9483 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9484 } 9485 9486 if response.StatusCode < 200 || response.StatusCode >= 300 { 9487 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 9488 } 9489 output := &UntagResourceOutput{} 9490 out.Result = output 9491 9492 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9493 return out, metadata, &smithy.DeserializationError{ 9494 Err: fmt.Errorf("failed to discard response body, %w", err), 9495 } 9496 } 9497 9498 return out, metadata, err 9499} 9500 9501func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9502 var errorBuffer bytes.Buffer 9503 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9504 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9505 } 9506 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9507 9508 errorCode := "UnknownError" 9509 errorMessage := errorCode 9510 9511 code := response.Header.Get("X-Amzn-ErrorType") 9512 if len(code) != 0 { 9513 errorCode = restjson.SanitizeErrorCode(code) 9514 } 9515 9516 var buff [1024]byte 9517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9518 9519 body := io.TeeReader(errorBody, ringBuffer) 9520 decoder := json.NewDecoder(body) 9521 decoder.UseNumber() 9522 code, message, err := restjson.GetErrorInfo(decoder) 9523 if err != nil { 9524 var snapshot bytes.Buffer 9525 io.Copy(&snapshot, ringBuffer) 9526 err = &smithy.DeserializationError{ 9527 Err: fmt.Errorf("failed to decode response body, %w", err), 9528 Snapshot: snapshot.Bytes(), 9529 } 9530 return err 9531 } 9532 9533 errorBody.Seek(0, io.SeekStart) 9534 if len(code) != 0 { 9535 errorCode = restjson.SanitizeErrorCode(code) 9536 } 9537 if len(message) != 0 { 9538 errorMessage = message 9539 } 9540 9541 switch { 9542 case strings.EqualFold("InvalidParameterValueException", errorCode): 9543 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 9544 9545 case strings.EqualFold("ResourceConflictException", errorCode): 9546 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 9547 9548 case strings.EqualFold("ResourceNotFoundException", errorCode): 9549 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9550 9551 case strings.EqualFold("ServiceException", errorCode): 9552 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 9553 9554 case strings.EqualFold("TooManyRequestsException", errorCode): 9555 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 9556 9557 default: 9558 genericError := &smithy.GenericAPIError{ 9559 Code: errorCode, 9560 Message: errorMessage, 9561 } 9562 return genericError 9563 9564 } 9565} 9566 9567type awsRestjson1_deserializeOpUpdateAlias struct { 9568} 9569 9570func (*awsRestjson1_deserializeOpUpdateAlias) ID() string { 9571 return "OperationDeserializer" 9572} 9573 9574func (m *awsRestjson1_deserializeOpUpdateAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9575 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9576) { 9577 out, metadata, err = next.HandleDeserialize(ctx, in) 9578 if err != nil { 9579 return out, metadata, err 9580 } 9581 9582 response, ok := out.RawResponse.(*smithyhttp.Response) 9583 if !ok { 9584 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9585 } 9586 9587 if response.StatusCode < 200 || response.StatusCode >= 300 { 9588 return out, metadata, awsRestjson1_deserializeOpErrorUpdateAlias(response, &metadata) 9589 } 9590 output := &UpdateAliasOutput{} 9591 out.Result = output 9592 9593 var buff [1024]byte 9594 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9595 9596 body := io.TeeReader(response.Body, ringBuffer) 9597 9598 decoder := json.NewDecoder(body) 9599 decoder.UseNumber() 9600 var shape interface{} 9601 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9602 var snapshot bytes.Buffer 9603 io.Copy(&snapshot, ringBuffer) 9604 err = &smithy.DeserializationError{ 9605 Err: fmt.Errorf("failed to decode response body, %w", err), 9606 Snapshot: snapshot.Bytes(), 9607 } 9608 return out, metadata, err 9609 } 9610 9611 err = awsRestjson1_deserializeOpDocumentUpdateAliasOutput(&output, shape) 9612 if err != nil { 9613 var snapshot bytes.Buffer 9614 io.Copy(&snapshot, ringBuffer) 9615 return out, metadata, &smithy.DeserializationError{ 9616 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 9617 Snapshot: snapshot.Bytes(), 9618 } 9619 } 9620 9621 return out, metadata, err 9622} 9623 9624func awsRestjson1_deserializeOpErrorUpdateAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9625 var errorBuffer bytes.Buffer 9626 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9627 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9628 } 9629 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9630 9631 errorCode := "UnknownError" 9632 errorMessage := errorCode 9633 9634 code := response.Header.Get("X-Amzn-ErrorType") 9635 if len(code) != 0 { 9636 errorCode = restjson.SanitizeErrorCode(code) 9637 } 9638 9639 var buff [1024]byte 9640 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9641 9642 body := io.TeeReader(errorBody, ringBuffer) 9643 decoder := json.NewDecoder(body) 9644 decoder.UseNumber() 9645 code, message, err := restjson.GetErrorInfo(decoder) 9646 if err != nil { 9647 var snapshot bytes.Buffer 9648 io.Copy(&snapshot, ringBuffer) 9649 err = &smithy.DeserializationError{ 9650 Err: fmt.Errorf("failed to decode response body, %w", err), 9651 Snapshot: snapshot.Bytes(), 9652 } 9653 return err 9654 } 9655 9656 errorBody.Seek(0, io.SeekStart) 9657 if len(code) != 0 { 9658 errorCode = restjson.SanitizeErrorCode(code) 9659 } 9660 if len(message) != 0 { 9661 errorMessage = message 9662 } 9663 9664 switch { 9665 case strings.EqualFold("InvalidParameterValueException", errorCode): 9666 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 9667 9668 case strings.EqualFold("PreconditionFailedException", errorCode): 9669 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 9670 9671 case strings.EqualFold("ResourceConflictException", errorCode): 9672 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 9673 9674 case strings.EqualFold("ResourceNotFoundException", errorCode): 9675 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9676 9677 case strings.EqualFold("ServiceException", errorCode): 9678 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 9679 9680 case strings.EqualFold("TooManyRequestsException", errorCode): 9681 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 9682 9683 default: 9684 genericError := &smithy.GenericAPIError{ 9685 Code: errorCode, 9686 Message: errorMessage, 9687 } 9688 return genericError 9689 9690 } 9691} 9692 9693func awsRestjson1_deserializeOpDocumentUpdateAliasOutput(v **UpdateAliasOutput, value interface{}) error { 9694 if v == nil { 9695 return fmt.Errorf("unexpected nil of type %T", v) 9696 } 9697 if value == nil { 9698 return nil 9699 } 9700 9701 shape, ok := value.(map[string]interface{}) 9702 if !ok { 9703 return fmt.Errorf("unexpected JSON type %v", value) 9704 } 9705 9706 var sv *UpdateAliasOutput 9707 if *v == nil { 9708 sv = &UpdateAliasOutput{} 9709 } else { 9710 sv = *v 9711 } 9712 9713 for key, value := range shape { 9714 switch key { 9715 case "AliasArn": 9716 if value != nil { 9717 jtv, ok := value.(string) 9718 if !ok { 9719 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 9720 } 9721 sv.AliasArn = ptr.String(jtv) 9722 } 9723 9724 case "Description": 9725 if value != nil { 9726 jtv, ok := value.(string) 9727 if !ok { 9728 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 9729 } 9730 sv.Description = ptr.String(jtv) 9731 } 9732 9733 case "FunctionVersion": 9734 if value != nil { 9735 jtv, ok := value.(string) 9736 if !ok { 9737 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 9738 } 9739 sv.FunctionVersion = ptr.String(jtv) 9740 } 9741 9742 case "Name": 9743 if value != nil { 9744 jtv, ok := value.(string) 9745 if !ok { 9746 return fmt.Errorf("expected Alias to be of type string, got %T instead", value) 9747 } 9748 sv.Name = ptr.String(jtv) 9749 } 9750 9751 case "RevisionId": 9752 if value != nil { 9753 jtv, ok := value.(string) 9754 if !ok { 9755 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9756 } 9757 sv.RevisionId = ptr.String(jtv) 9758 } 9759 9760 case "RoutingConfig": 9761 if err := awsRestjson1_deserializeDocumentAliasRoutingConfiguration(&sv.RoutingConfig, value); err != nil { 9762 return err 9763 } 9764 9765 default: 9766 _, _ = key, value 9767 9768 } 9769 } 9770 *v = sv 9771 return nil 9772} 9773 9774type awsRestjson1_deserializeOpUpdateCodeSigningConfig struct { 9775} 9776 9777func (*awsRestjson1_deserializeOpUpdateCodeSigningConfig) ID() string { 9778 return "OperationDeserializer" 9779} 9780 9781func (m *awsRestjson1_deserializeOpUpdateCodeSigningConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9782 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9783) { 9784 out, metadata, err = next.HandleDeserialize(ctx, in) 9785 if err != nil { 9786 return out, metadata, err 9787 } 9788 9789 response, ok := out.RawResponse.(*smithyhttp.Response) 9790 if !ok { 9791 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9792 } 9793 9794 if response.StatusCode < 200 || response.StatusCode >= 300 { 9795 return out, metadata, awsRestjson1_deserializeOpErrorUpdateCodeSigningConfig(response, &metadata) 9796 } 9797 output := &UpdateCodeSigningConfigOutput{} 9798 out.Result = output 9799 9800 var buff [1024]byte 9801 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9802 9803 body := io.TeeReader(response.Body, ringBuffer) 9804 9805 decoder := json.NewDecoder(body) 9806 decoder.UseNumber() 9807 var shape interface{} 9808 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9809 var snapshot bytes.Buffer 9810 io.Copy(&snapshot, ringBuffer) 9811 err = &smithy.DeserializationError{ 9812 Err: fmt.Errorf("failed to decode response body, %w", err), 9813 Snapshot: snapshot.Bytes(), 9814 } 9815 return out, metadata, err 9816 } 9817 9818 err = awsRestjson1_deserializeOpDocumentUpdateCodeSigningConfigOutput(&output, shape) 9819 if err != nil { 9820 var snapshot bytes.Buffer 9821 io.Copy(&snapshot, ringBuffer) 9822 return out, metadata, &smithy.DeserializationError{ 9823 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 9824 Snapshot: snapshot.Bytes(), 9825 } 9826 } 9827 9828 return out, metadata, err 9829} 9830 9831func awsRestjson1_deserializeOpErrorUpdateCodeSigningConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9832 var errorBuffer bytes.Buffer 9833 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9834 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9835 } 9836 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9837 9838 errorCode := "UnknownError" 9839 errorMessage := errorCode 9840 9841 code := response.Header.Get("X-Amzn-ErrorType") 9842 if len(code) != 0 { 9843 errorCode = restjson.SanitizeErrorCode(code) 9844 } 9845 9846 var buff [1024]byte 9847 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9848 9849 body := io.TeeReader(errorBody, ringBuffer) 9850 decoder := json.NewDecoder(body) 9851 decoder.UseNumber() 9852 code, message, err := restjson.GetErrorInfo(decoder) 9853 if err != nil { 9854 var snapshot bytes.Buffer 9855 io.Copy(&snapshot, ringBuffer) 9856 err = &smithy.DeserializationError{ 9857 Err: fmt.Errorf("failed to decode response body, %w", err), 9858 Snapshot: snapshot.Bytes(), 9859 } 9860 return err 9861 } 9862 9863 errorBody.Seek(0, io.SeekStart) 9864 if len(code) != 0 { 9865 errorCode = restjson.SanitizeErrorCode(code) 9866 } 9867 if len(message) != 0 { 9868 errorMessage = message 9869 } 9870 9871 switch { 9872 case strings.EqualFold("InvalidParameterValueException", errorCode): 9873 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 9874 9875 case strings.EqualFold("ResourceNotFoundException", errorCode): 9876 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9877 9878 case strings.EqualFold("ServiceException", errorCode): 9879 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 9880 9881 default: 9882 genericError := &smithy.GenericAPIError{ 9883 Code: errorCode, 9884 Message: errorMessage, 9885 } 9886 return genericError 9887 9888 } 9889} 9890 9891func awsRestjson1_deserializeOpDocumentUpdateCodeSigningConfigOutput(v **UpdateCodeSigningConfigOutput, value interface{}) error { 9892 if v == nil { 9893 return fmt.Errorf("unexpected nil of type %T", v) 9894 } 9895 if value == nil { 9896 return nil 9897 } 9898 9899 shape, ok := value.(map[string]interface{}) 9900 if !ok { 9901 return fmt.Errorf("unexpected JSON type %v", value) 9902 } 9903 9904 var sv *UpdateCodeSigningConfigOutput 9905 if *v == nil { 9906 sv = &UpdateCodeSigningConfigOutput{} 9907 } else { 9908 sv = *v 9909 } 9910 9911 for key, value := range shape { 9912 switch key { 9913 case "CodeSigningConfig": 9914 if err := awsRestjson1_deserializeDocumentCodeSigningConfig(&sv.CodeSigningConfig, value); err != nil { 9915 return err 9916 } 9917 9918 default: 9919 _, _ = key, value 9920 9921 } 9922 } 9923 *v = sv 9924 return nil 9925} 9926 9927type awsRestjson1_deserializeOpUpdateEventSourceMapping struct { 9928} 9929 9930func (*awsRestjson1_deserializeOpUpdateEventSourceMapping) ID() string { 9931 return "OperationDeserializer" 9932} 9933 9934func (m *awsRestjson1_deserializeOpUpdateEventSourceMapping) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9935 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9936) { 9937 out, metadata, err = next.HandleDeserialize(ctx, in) 9938 if err != nil { 9939 return out, metadata, err 9940 } 9941 9942 response, ok := out.RawResponse.(*smithyhttp.Response) 9943 if !ok { 9944 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9945 } 9946 9947 if response.StatusCode < 200 || response.StatusCode >= 300 { 9948 return out, metadata, awsRestjson1_deserializeOpErrorUpdateEventSourceMapping(response, &metadata) 9949 } 9950 output := &UpdateEventSourceMappingOutput{} 9951 out.Result = output 9952 9953 var buff [1024]byte 9954 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9955 9956 body := io.TeeReader(response.Body, ringBuffer) 9957 9958 decoder := json.NewDecoder(body) 9959 decoder.UseNumber() 9960 var shape interface{} 9961 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9962 var snapshot bytes.Buffer 9963 io.Copy(&snapshot, ringBuffer) 9964 err = &smithy.DeserializationError{ 9965 Err: fmt.Errorf("failed to decode response body, %w", err), 9966 Snapshot: snapshot.Bytes(), 9967 } 9968 return out, metadata, err 9969 } 9970 9971 err = awsRestjson1_deserializeOpDocumentUpdateEventSourceMappingOutput(&output, shape) 9972 if err != nil { 9973 var snapshot bytes.Buffer 9974 io.Copy(&snapshot, ringBuffer) 9975 return out, metadata, &smithy.DeserializationError{ 9976 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 9977 Snapshot: snapshot.Bytes(), 9978 } 9979 } 9980 9981 return out, metadata, err 9982} 9983 9984func awsRestjson1_deserializeOpErrorUpdateEventSourceMapping(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9985 var errorBuffer bytes.Buffer 9986 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9987 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9988 } 9989 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9990 9991 errorCode := "UnknownError" 9992 errorMessage := errorCode 9993 9994 code := response.Header.Get("X-Amzn-ErrorType") 9995 if len(code) != 0 { 9996 errorCode = restjson.SanitizeErrorCode(code) 9997 } 9998 9999 var buff [1024]byte 10000 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10001 10002 body := io.TeeReader(errorBody, ringBuffer) 10003 decoder := json.NewDecoder(body) 10004 decoder.UseNumber() 10005 code, message, err := restjson.GetErrorInfo(decoder) 10006 if err != nil { 10007 var snapshot bytes.Buffer 10008 io.Copy(&snapshot, ringBuffer) 10009 err = &smithy.DeserializationError{ 10010 Err: fmt.Errorf("failed to decode response body, %w", err), 10011 Snapshot: snapshot.Bytes(), 10012 } 10013 return err 10014 } 10015 10016 errorBody.Seek(0, io.SeekStart) 10017 if len(code) != 0 { 10018 errorCode = restjson.SanitizeErrorCode(code) 10019 } 10020 if len(message) != 0 { 10021 errorMessage = message 10022 } 10023 10024 switch { 10025 case strings.EqualFold("InvalidParameterValueException", errorCode): 10026 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 10027 10028 case strings.EqualFold("ResourceConflictException", errorCode): 10029 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 10030 10031 case strings.EqualFold("ResourceInUseException", errorCode): 10032 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 10033 10034 case strings.EqualFold("ResourceNotFoundException", errorCode): 10035 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 10036 10037 case strings.EqualFold("ServiceException", errorCode): 10038 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 10039 10040 case strings.EqualFold("TooManyRequestsException", errorCode): 10041 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 10042 10043 default: 10044 genericError := &smithy.GenericAPIError{ 10045 Code: errorCode, 10046 Message: errorMessage, 10047 } 10048 return genericError 10049 10050 } 10051} 10052 10053func awsRestjson1_deserializeOpDocumentUpdateEventSourceMappingOutput(v **UpdateEventSourceMappingOutput, value interface{}) error { 10054 if v == nil { 10055 return fmt.Errorf("unexpected nil of type %T", v) 10056 } 10057 if value == nil { 10058 return nil 10059 } 10060 10061 shape, ok := value.(map[string]interface{}) 10062 if !ok { 10063 return fmt.Errorf("unexpected JSON type %v", value) 10064 } 10065 10066 var sv *UpdateEventSourceMappingOutput 10067 if *v == nil { 10068 sv = &UpdateEventSourceMappingOutput{} 10069 } else { 10070 sv = *v 10071 } 10072 10073 for key, value := range shape { 10074 switch key { 10075 case "BatchSize": 10076 if value != nil { 10077 jtv, ok := value.(json.Number) 10078 if !ok { 10079 return fmt.Errorf("expected BatchSize to be json.Number, got %T instead", value) 10080 } 10081 i64, err := jtv.Int64() 10082 if err != nil { 10083 return err 10084 } 10085 sv.BatchSize = ptr.Int32(int32(i64)) 10086 } 10087 10088 case "BisectBatchOnFunctionError": 10089 if value != nil { 10090 jtv, ok := value.(bool) 10091 if !ok { 10092 return fmt.Errorf("expected BisectBatchOnFunctionError to be of type *bool, got %T instead", value) 10093 } 10094 sv.BisectBatchOnFunctionError = ptr.Bool(jtv) 10095 } 10096 10097 case "DestinationConfig": 10098 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 10099 return err 10100 } 10101 10102 case "EventSourceArn": 10103 if value != nil { 10104 jtv, ok := value.(string) 10105 if !ok { 10106 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10107 } 10108 sv.EventSourceArn = ptr.String(jtv) 10109 } 10110 10111 case "FunctionArn": 10112 if value != nil { 10113 jtv, ok := value.(string) 10114 if !ok { 10115 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 10116 } 10117 sv.FunctionArn = ptr.String(jtv) 10118 } 10119 10120 case "FunctionResponseTypes": 10121 if err := awsRestjson1_deserializeDocumentFunctionResponseTypeList(&sv.FunctionResponseTypes, value); err != nil { 10122 return err 10123 } 10124 10125 case "LastModified": 10126 if value != nil { 10127 jtv, ok := value.(json.Number) 10128 if !ok { 10129 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 10130 } 10131 f64, err := jtv.Float64() 10132 if err != nil { 10133 return err 10134 } 10135 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10136 } 10137 10138 case "LastProcessingResult": 10139 if value != nil { 10140 jtv, ok := value.(string) 10141 if !ok { 10142 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10143 } 10144 sv.LastProcessingResult = ptr.String(jtv) 10145 } 10146 10147 case "MaximumBatchingWindowInSeconds": 10148 if value != nil { 10149 jtv, ok := value.(json.Number) 10150 if !ok { 10151 return fmt.Errorf("expected MaximumBatchingWindowInSeconds to be json.Number, got %T instead", value) 10152 } 10153 i64, err := jtv.Int64() 10154 if err != nil { 10155 return err 10156 } 10157 sv.MaximumBatchingWindowInSeconds = ptr.Int32(int32(i64)) 10158 } 10159 10160 case "MaximumRecordAgeInSeconds": 10161 if value != nil { 10162 jtv, ok := value.(json.Number) 10163 if !ok { 10164 return fmt.Errorf("expected MaximumRecordAgeInSeconds to be json.Number, got %T instead", value) 10165 } 10166 i64, err := jtv.Int64() 10167 if err != nil { 10168 return err 10169 } 10170 sv.MaximumRecordAgeInSeconds = ptr.Int32(int32(i64)) 10171 } 10172 10173 case "MaximumRetryAttempts": 10174 if value != nil { 10175 jtv, ok := value.(json.Number) 10176 if !ok { 10177 return fmt.Errorf("expected MaximumRetryAttemptsEventSourceMapping to be json.Number, got %T instead", value) 10178 } 10179 i64, err := jtv.Int64() 10180 if err != nil { 10181 return err 10182 } 10183 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 10184 } 10185 10186 case "ParallelizationFactor": 10187 if value != nil { 10188 jtv, ok := value.(json.Number) 10189 if !ok { 10190 return fmt.Errorf("expected ParallelizationFactor to be json.Number, got %T instead", value) 10191 } 10192 i64, err := jtv.Int64() 10193 if err != nil { 10194 return err 10195 } 10196 sv.ParallelizationFactor = ptr.Int32(int32(i64)) 10197 } 10198 10199 case "Queues": 10200 if err := awsRestjson1_deserializeDocumentQueues(&sv.Queues, value); err != nil { 10201 return err 10202 } 10203 10204 case "SelfManagedEventSource": 10205 if err := awsRestjson1_deserializeDocumentSelfManagedEventSource(&sv.SelfManagedEventSource, value); err != nil { 10206 return err 10207 } 10208 10209 case "SourceAccessConfigurations": 10210 if err := awsRestjson1_deserializeDocumentSourceAccessConfigurations(&sv.SourceAccessConfigurations, value); err != nil { 10211 return err 10212 } 10213 10214 case "StartingPosition": 10215 if value != nil { 10216 jtv, ok := value.(string) 10217 if !ok { 10218 return fmt.Errorf("expected EventSourcePosition to be of type string, got %T instead", value) 10219 } 10220 sv.StartingPosition = types.EventSourcePosition(jtv) 10221 } 10222 10223 case "StartingPositionTimestamp": 10224 if value != nil { 10225 jtv, ok := value.(json.Number) 10226 if !ok { 10227 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 10228 } 10229 f64, err := jtv.Float64() 10230 if err != nil { 10231 return err 10232 } 10233 sv.StartingPositionTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10234 } 10235 10236 case "State": 10237 if value != nil { 10238 jtv, ok := value.(string) 10239 if !ok { 10240 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10241 } 10242 sv.State = ptr.String(jtv) 10243 } 10244 10245 case "StateTransitionReason": 10246 if value != nil { 10247 jtv, ok := value.(string) 10248 if !ok { 10249 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10250 } 10251 sv.StateTransitionReason = ptr.String(jtv) 10252 } 10253 10254 case "Topics": 10255 if err := awsRestjson1_deserializeDocumentTopics(&sv.Topics, value); err != nil { 10256 return err 10257 } 10258 10259 case "TumblingWindowInSeconds": 10260 if value != nil { 10261 jtv, ok := value.(json.Number) 10262 if !ok { 10263 return fmt.Errorf("expected TumblingWindowInSeconds to be json.Number, got %T instead", value) 10264 } 10265 i64, err := jtv.Int64() 10266 if err != nil { 10267 return err 10268 } 10269 sv.TumblingWindowInSeconds = ptr.Int32(int32(i64)) 10270 } 10271 10272 case "UUID": 10273 if value != nil { 10274 jtv, ok := value.(string) 10275 if !ok { 10276 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10277 } 10278 sv.UUID = ptr.String(jtv) 10279 } 10280 10281 default: 10282 _, _ = key, value 10283 10284 } 10285 } 10286 *v = sv 10287 return nil 10288} 10289 10290type awsRestjson1_deserializeOpUpdateFunctionCode struct { 10291} 10292 10293func (*awsRestjson1_deserializeOpUpdateFunctionCode) ID() string { 10294 return "OperationDeserializer" 10295} 10296 10297func (m *awsRestjson1_deserializeOpUpdateFunctionCode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10298 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10299) { 10300 out, metadata, err = next.HandleDeserialize(ctx, in) 10301 if err != nil { 10302 return out, metadata, err 10303 } 10304 10305 response, ok := out.RawResponse.(*smithyhttp.Response) 10306 if !ok { 10307 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10308 } 10309 10310 if response.StatusCode < 200 || response.StatusCode >= 300 { 10311 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFunctionCode(response, &metadata) 10312 } 10313 output := &UpdateFunctionCodeOutput{} 10314 out.Result = output 10315 10316 var buff [1024]byte 10317 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10318 10319 body := io.TeeReader(response.Body, ringBuffer) 10320 10321 decoder := json.NewDecoder(body) 10322 decoder.UseNumber() 10323 var shape interface{} 10324 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10325 var snapshot bytes.Buffer 10326 io.Copy(&snapshot, ringBuffer) 10327 err = &smithy.DeserializationError{ 10328 Err: fmt.Errorf("failed to decode response body, %w", err), 10329 Snapshot: snapshot.Bytes(), 10330 } 10331 return out, metadata, err 10332 } 10333 10334 err = awsRestjson1_deserializeOpDocumentUpdateFunctionCodeOutput(&output, shape) 10335 if err != nil { 10336 var snapshot bytes.Buffer 10337 io.Copy(&snapshot, ringBuffer) 10338 return out, metadata, &smithy.DeserializationError{ 10339 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 10340 Snapshot: snapshot.Bytes(), 10341 } 10342 } 10343 10344 return out, metadata, err 10345} 10346 10347func awsRestjson1_deserializeOpErrorUpdateFunctionCode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10348 var errorBuffer bytes.Buffer 10349 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10350 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10351 } 10352 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10353 10354 errorCode := "UnknownError" 10355 errorMessage := errorCode 10356 10357 code := response.Header.Get("X-Amzn-ErrorType") 10358 if len(code) != 0 { 10359 errorCode = restjson.SanitizeErrorCode(code) 10360 } 10361 10362 var buff [1024]byte 10363 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10364 10365 body := io.TeeReader(errorBody, ringBuffer) 10366 decoder := json.NewDecoder(body) 10367 decoder.UseNumber() 10368 code, message, err := restjson.GetErrorInfo(decoder) 10369 if err != nil { 10370 var snapshot bytes.Buffer 10371 io.Copy(&snapshot, ringBuffer) 10372 err = &smithy.DeserializationError{ 10373 Err: fmt.Errorf("failed to decode response body, %w", err), 10374 Snapshot: snapshot.Bytes(), 10375 } 10376 return err 10377 } 10378 10379 errorBody.Seek(0, io.SeekStart) 10380 if len(code) != 0 { 10381 errorCode = restjson.SanitizeErrorCode(code) 10382 } 10383 if len(message) != 0 { 10384 errorMessage = message 10385 } 10386 10387 switch { 10388 case strings.EqualFold("CodeSigningConfigNotFoundException", errorCode): 10389 return awsRestjson1_deserializeErrorCodeSigningConfigNotFoundException(response, errorBody) 10390 10391 case strings.EqualFold("CodeStorageExceededException", errorCode): 10392 return awsRestjson1_deserializeErrorCodeStorageExceededException(response, errorBody) 10393 10394 case strings.EqualFold("CodeVerificationFailedException", errorCode): 10395 return awsRestjson1_deserializeErrorCodeVerificationFailedException(response, errorBody) 10396 10397 case strings.EqualFold("InvalidCodeSignatureException", errorCode): 10398 return awsRestjson1_deserializeErrorInvalidCodeSignatureException(response, errorBody) 10399 10400 case strings.EqualFold("InvalidParameterValueException", errorCode): 10401 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 10402 10403 case strings.EqualFold("PreconditionFailedException", errorCode): 10404 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 10405 10406 case strings.EqualFold("ResourceConflictException", errorCode): 10407 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 10408 10409 case strings.EqualFold("ResourceNotFoundException", errorCode): 10410 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 10411 10412 case strings.EqualFold("ServiceException", errorCode): 10413 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 10414 10415 case strings.EqualFold("TooManyRequestsException", errorCode): 10416 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 10417 10418 default: 10419 genericError := &smithy.GenericAPIError{ 10420 Code: errorCode, 10421 Message: errorMessage, 10422 } 10423 return genericError 10424 10425 } 10426} 10427 10428func awsRestjson1_deserializeOpDocumentUpdateFunctionCodeOutput(v **UpdateFunctionCodeOutput, value interface{}) error { 10429 if v == nil { 10430 return fmt.Errorf("unexpected nil of type %T", v) 10431 } 10432 if value == nil { 10433 return nil 10434 } 10435 10436 shape, ok := value.(map[string]interface{}) 10437 if !ok { 10438 return fmt.Errorf("unexpected JSON type %v", value) 10439 } 10440 10441 var sv *UpdateFunctionCodeOutput 10442 if *v == nil { 10443 sv = &UpdateFunctionCodeOutput{} 10444 } else { 10445 sv = *v 10446 } 10447 10448 for key, value := range shape { 10449 switch key { 10450 case "CodeSha256": 10451 if value != nil { 10452 jtv, ok := value.(string) 10453 if !ok { 10454 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10455 } 10456 sv.CodeSha256 = ptr.String(jtv) 10457 } 10458 10459 case "CodeSize": 10460 if value != nil { 10461 jtv, ok := value.(json.Number) 10462 if !ok { 10463 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 10464 } 10465 i64, err := jtv.Int64() 10466 if err != nil { 10467 return err 10468 } 10469 sv.CodeSize = i64 10470 } 10471 10472 case "DeadLetterConfig": 10473 if err := awsRestjson1_deserializeDocumentDeadLetterConfig(&sv.DeadLetterConfig, value); err != nil { 10474 return err 10475 } 10476 10477 case "Description": 10478 if value != nil { 10479 jtv, ok := value.(string) 10480 if !ok { 10481 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 10482 } 10483 sv.Description = ptr.String(jtv) 10484 } 10485 10486 case "Environment": 10487 if err := awsRestjson1_deserializeDocumentEnvironmentResponse(&sv.Environment, value); err != nil { 10488 return err 10489 } 10490 10491 case "FileSystemConfigs": 10492 if err := awsRestjson1_deserializeDocumentFileSystemConfigList(&sv.FileSystemConfigs, value); err != nil { 10493 return err 10494 } 10495 10496 case "FunctionArn": 10497 if value != nil { 10498 jtv, ok := value.(string) 10499 if !ok { 10500 return fmt.Errorf("expected NameSpacedFunctionArn to be of type string, got %T instead", value) 10501 } 10502 sv.FunctionArn = ptr.String(jtv) 10503 } 10504 10505 case "FunctionName": 10506 if value != nil { 10507 jtv, ok := value.(string) 10508 if !ok { 10509 return fmt.Errorf("expected NamespacedFunctionName to be of type string, got %T instead", value) 10510 } 10511 sv.FunctionName = ptr.String(jtv) 10512 } 10513 10514 case "Handler": 10515 if value != nil { 10516 jtv, ok := value.(string) 10517 if !ok { 10518 return fmt.Errorf("expected Handler to be of type string, got %T instead", value) 10519 } 10520 sv.Handler = ptr.String(jtv) 10521 } 10522 10523 case "ImageConfigResponse": 10524 if err := awsRestjson1_deserializeDocumentImageConfigResponse(&sv.ImageConfigResponse, value); err != nil { 10525 return err 10526 } 10527 10528 case "KMSKeyArn": 10529 if value != nil { 10530 jtv, ok := value.(string) 10531 if !ok { 10532 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 10533 } 10534 sv.KMSKeyArn = ptr.String(jtv) 10535 } 10536 10537 case "LastModified": 10538 if value != nil { 10539 jtv, ok := value.(string) 10540 if !ok { 10541 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 10542 } 10543 sv.LastModified = ptr.String(jtv) 10544 } 10545 10546 case "LastUpdateStatus": 10547 if value != nil { 10548 jtv, ok := value.(string) 10549 if !ok { 10550 return fmt.Errorf("expected LastUpdateStatus to be of type string, got %T instead", value) 10551 } 10552 sv.LastUpdateStatus = types.LastUpdateStatus(jtv) 10553 } 10554 10555 case "LastUpdateStatusReason": 10556 if value != nil { 10557 jtv, ok := value.(string) 10558 if !ok { 10559 return fmt.Errorf("expected LastUpdateStatusReason to be of type string, got %T instead", value) 10560 } 10561 sv.LastUpdateStatusReason = ptr.String(jtv) 10562 } 10563 10564 case "LastUpdateStatusReasonCode": 10565 if value != nil { 10566 jtv, ok := value.(string) 10567 if !ok { 10568 return fmt.Errorf("expected LastUpdateStatusReasonCode to be of type string, got %T instead", value) 10569 } 10570 sv.LastUpdateStatusReasonCode = types.LastUpdateStatusReasonCode(jtv) 10571 } 10572 10573 case "Layers": 10574 if err := awsRestjson1_deserializeDocumentLayersReferenceList(&sv.Layers, value); err != nil { 10575 return err 10576 } 10577 10578 case "MasterArn": 10579 if value != nil { 10580 jtv, ok := value.(string) 10581 if !ok { 10582 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 10583 } 10584 sv.MasterArn = ptr.String(jtv) 10585 } 10586 10587 case "MemorySize": 10588 if value != nil { 10589 jtv, ok := value.(json.Number) 10590 if !ok { 10591 return fmt.Errorf("expected MemorySize to be json.Number, got %T instead", value) 10592 } 10593 i64, err := jtv.Int64() 10594 if err != nil { 10595 return err 10596 } 10597 sv.MemorySize = ptr.Int32(int32(i64)) 10598 } 10599 10600 case "PackageType": 10601 if value != nil { 10602 jtv, ok := value.(string) 10603 if !ok { 10604 return fmt.Errorf("expected PackageType to be of type string, got %T instead", value) 10605 } 10606 sv.PackageType = types.PackageType(jtv) 10607 } 10608 10609 case "RevisionId": 10610 if value != nil { 10611 jtv, ok := value.(string) 10612 if !ok { 10613 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10614 } 10615 sv.RevisionId = ptr.String(jtv) 10616 } 10617 10618 case "Role": 10619 if value != nil { 10620 jtv, ok := value.(string) 10621 if !ok { 10622 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 10623 } 10624 sv.Role = ptr.String(jtv) 10625 } 10626 10627 case "Runtime": 10628 if value != nil { 10629 jtv, ok := value.(string) 10630 if !ok { 10631 return fmt.Errorf("expected Runtime to be of type string, got %T instead", value) 10632 } 10633 sv.Runtime = types.Runtime(jtv) 10634 } 10635 10636 case "SigningJobArn": 10637 if value != nil { 10638 jtv, ok := value.(string) 10639 if !ok { 10640 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10641 } 10642 sv.SigningJobArn = ptr.String(jtv) 10643 } 10644 10645 case "SigningProfileVersionArn": 10646 if value != nil { 10647 jtv, ok := value.(string) 10648 if !ok { 10649 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10650 } 10651 sv.SigningProfileVersionArn = ptr.String(jtv) 10652 } 10653 10654 case "State": 10655 if value != nil { 10656 jtv, ok := value.(string) 10657 if !ok { 10658 return fmt.Errorf("expected State to be of type string, got %T instead", value) 10659 } 10660 sv.State = types.State(jtv) 10661 } 10662 10663 case "StateReason": 10664 if value != nil { 10665 jtv, ok := value.(string) 10666 if !ok { 10667 return fmt.Errorf("expected StateReason to be of type string, got %T instead", value) 10668 } 10669 sv.StateReason = ptr.String(jtv) 10670 } 10671 10672 case "StateReasonCode": 10673 if value != nil { 10674 jtv, ok := value.(string) 10675 if !ok { 10676 return fmt.Errorf("expected StateReasonCode to be of type string, got %T instead", value) 10677 } 10678 sv.StateReasonCode = types.StateReasonCode(jtv) 10679 } 10680 10681 case "Timeout": 10682 if value != nil { 10683 jtv, ok := value.(json.Number) 10684 if !ok { 10685 return fmt.Errorf("expected Timeout to be json.Number, got %T instead", value) 10686 } 10687 i64, err := jtv.Int64() 10688 if err != nil { 10689 return err 10690 } 10691 sv.Timeout = ptr.Int32(int32(i64)) 10692 } 10693 10694 case "TracingConfig": 10695 if err := awsRestjson1_deserializeDocumentTracingConfigResponse(&sv.TracingConfig, value); err != nil { 10696 return err 10697 } 10698 10699 case "Version": 10700 if value != nil { 10701 jtv, ok := value.(string) 10702 if !ok { 10703 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 10704 } 10705 sv.Version = ptr.String(jtv) 10706 } 10707 10708 case "VpcConfig": 10709 if err := awsRestjson1_deserializeDocumentVpcConfigResponse(&sv.VpcConfig, value); err != nil { 10710 return err 10711 } 10712 10713 default: 10714 _, _ = key, value 10715 10716 } 10717 } 10718 *v = sv 10719 return nil 10720} 10721 10722type awsRestjson1_deserializeOpUpdateFunctionConfiguration struct { 10723} 10724 10725func (*awsRestjson1_deserializeOpUpdateFunctionConfiguration) ID() string { 10726 return "OperationDeserializer" 10727} 10728 10729func (m *awsRestjson1_deserializeOpUpdateFunctionConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10730 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10731) { 10732 out, metadata, err = next.HandleDeserialize(ctx, in) 10733 if err != nil { 10734 return out, metadata, err 10735 } 10736 10737 response, ok := out.RawResponse.(*smithyhttp.Response) 10738 if !ok { 10739 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10740 } 10741 10742 if response.StatusCode < 200 || response.StatusCode >= 300 { 10743 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFunctionConfiguration(response, &metadata) 10744 } 10745 output := &UpdateFunctionConfigurationOutput{} 10746 out.Result = output 10747 10748 var buff [1024]byte 10749 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10750 10751 body := io.TeeReader(response.Body, ringBuffer) 10752 10753 decoder := json.NewDecoder(body) 10754 decoder.UseNumber() 10755 var shape interface{} 10756 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10757 var snapshot bytes.Buffer 10758 io.Copy(&snapshot, ringBuffer) 10759 err = &smithy.DeserializationError{ 10760 Err: fmt.Errorf("failed to decode response body, %w", err), 10761 Snapshot: snapshot.Bytes(), 10762 } 10763 return out, metadata, err 10764 } 10765 10766 err = awsRestjson1_deserializeOpDocumentUpdateFunctionConfigurationOutput(&output, shape) 10767 if err != nil { 10768 var snapshot bytes.Buffer 10769 io.Copy(&snapshot, ringBuffer) 10770 return out, metadata, &smithy.DeserializationError{ 10771 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 10772 Snapshot: snapshot.Bytes(), 10773 } 10774 } 10775 10776 return out, metadata, err 10777} 10778 10779func awsRestjson1_deserializeOpErrorUpdateFunctionConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10780 var errorBuffer bytes.Buffer 10781 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10782 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10783 } 10784 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10785 10786 errorCode := "UnknownError" 10787 errorMessage := errorCode 10788 10789 code := response.Header.Get("X-Amzn-ErrorType") 10790 if len(code) != 0 { 10791 errorCode = restjson.SanitizeErrorCode(code) 10792 } 10793 10794 var buff [1024]byte 10795 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10796 10797 body := io.TeeReader(errorBody, ringBuffer) 10798 decoder := json.NewDecoder(body) 10799 decoder.UseNumber() 10800 code, message, err := restjson.GetErrorInfo(decoder) 10801 if err != nil { 10802 var snapshot bytes.Buffer 10803 io.Copy(&snapshot, ringBuffer) 10804 err = &smithy.DeserializationError{ 10805 Err: fmt.Errorf("failed to decode response body, %w", err), 10806 Snapshot: snapshot.Bytes(), 10807 } 10808 return err 10809 } 10810 10811 errorBody.Seek(0, io.SeekStart) 10812 if len(code) != 0 { 10813 errorCode = restjson.SanitizeErrorCode(code) 10814 } 10815 if len(message) != 0 { 10816 errorMessage = message 10817 } 10818 10819 switch { 10820 case strings.EqualFold("CodeSigningConfigNotFoundException", errorCode): 10821 return awsRestjson1_deserializeErrorCodeSigningConfigNotFoundException(response, errorBody) 10822 10823 case strings.EqualFold("CodeVerificationFailedException", errorCode): 10824 return awsRestjson1_deserializeErrorCodeVerificationFailedException(response, errorBody) 10825 10826 case strings.EqualFold("InvalidCodeSignatureException", errorCode): 10827 return awsRestjson1_deserializeErrorInvalidCodeSignatureException(response, errorBody) 10828 10829 case strings.EqualFold("InvalidParameterValueException", errorCode): 10830 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 10831 10832 case strings.EqualFold("PreconditionFailedException", errorCode): 10833 return awsRestjson1_deserializeErrorPreconditionFailedException(response, errorBody) 10834 10835 case strings.EqualFold("ResourceConflictException", errorCode): 10836 return awsRestjson1_deserializeErrorResourceConflictException(response, errorBody) 10837 10838 case strings.EqualFold("ResourceNotFoundException", errorCode): 10839 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 10840 10841 case strings.EqualFold("ServiceException", errorCode): 10842 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 10843 10844 case strings.EqualFold("TooManyRequestsException", errorCode): 10845 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 10846 10847 default: 10848 genericError := &smithy.GenericAPIError{ 10849 Code: errorCode, 10850 Message: errorMessage, 10851 } 10852 return genericError 10853 10854 } 10855} 10856 10857func awsRestjson1_deserializeOpDocumentUpdateFunctionConfigurationOutput(v **UpdateFunctionConfigurationOutput, value interface{}) error { 10858 if v == nil { 10859 return fmt.Errorf("unexpected nil of type %T", v) 10860 } 10861 if value == nil { 10862 return nil 10863 } 10864 10865 shape, ok := value.(map[string]interface{}) 10866 if !ok { 10867 return fmt.Errorf("unexpected JSON type %v", value) 10868 } 10869 10870 var sv *UpdateFunctionConfigurationOutput 10871 if *v == nil { 10872 sv = &UpdateFunctionConfigurationOutput{} 10873 } else { 10874 sv = *v 10875 } 10876 10877 for key, value := range shape { 10878 switch key { 10879 case "CodeSha256": 10880 if value != nil { 10881 jtv, ok := value.(string) 10882 if !ok { 10883 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10884 } 10885 sv.CodeSha256 = ptr.String(jtv) 10886 } 10887 10888 case "CodeSize": 10889 if value != nil { 10890 jtv, ok := value.(json.Number) 10891 if !ok { 10892 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 10893 } 10894 i64, err := jtv.Int64() 10895 if err != nil { 10896 return err 10897 } 10898 sv.CodeSize = i64 10899 } 10900 10901 case "DeadLetterConfig": 10902 if err := awsRestjson1_deserializeDocumentDeadLetterConfig(&sv.DeadLetterConfig, value); err != nil { 10903 return err 10904 } 10905 10906 case "Description": 10907 if value != nil { 10908 jtv, ok := value.(string) 10909 if !ok { 10910 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 10911 } 10912 sv.Description = ptr.String(jtv) 10913 } 10914 10915 case "Environment": 10916 if err := awsRestjson1_deserializeDocumentEnvironmentResponse(&sv.Environment, value); err != nil { 10917 return err 10918 } 10919 10920 case "FileSystemConfigs": 10921 if err := awsRestjson1_deserializeDocumentFileSystemConfigList(&sv.FileSystemConfigs, value); err != nil { 10922 return err 10923 } 10924 10925 case "FunctionArn": 10926 if value != nil { 10927 jtv, ok := value.(string) 10928 if !ok { 10929 return fmt.Errorf("expected NameSpacedFunctionArn to be of type string, got %T instead", value) 10930 } 10931 sv.FunctionArn = ptr.String(jtv) 10932 } 10933 10934 case "FunctionName": 10935 if value != nil { 10936 jtv, ok := value.(string) 10937 if !ok { 10938 return fmt.Errorf("expected NamespacedFunctionName to be of type string, got %T instead", value) 10939 } 10940 sv.FunctionName = ptr.String(jtv) 10941 } 10942 10943 case "Handler": 10944 if value != nil { 10945 jtv, ok := value.(string) 10946 if !ok { 10947 return fmt.Errorf("expected Handler to be of type string, got %T instead", value) 10948 } 10949 sv.Handler = ptr.String(jtv) 10950 } 10951 10952 case "ImageConfigResponse": 10953 if err := awsRestjson1_deserializeDocumentImageConfigResponse(&sv.ImageConfigResponse, value); err != nil { 10954 return err 10955 } 10956 10957 case "KMSKeyArn": 10958 if value != nil { 10959 jtv, ok := value.(string) 10960 if !ok { 10961 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 10962 } 10963 sv.KMSKeyArn = ptr.String(jtv) 10964 } 10965 10966 case "LastModified": 10967 if value != nil { 10968 jtv, ok := value.(string) 10969 if !ok { 10970 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 10971 } 10972 sv.LastModified = ptr.String(jtv) 10973 } 10974 10975 case "LastUpdateStatus": 10976 if value != nil { 10977 jtv, ok := value.(string) 10978 if !ok { 10979 return fmt.Errorf("expected LastUpdateStatus to be of type string, got %T instead", value) 10980 } 10981 sv.LastUpdateStatus = types.LastUpdateStatus(jtv) 10982 } 10983 10984 case "LastUpdateStatusReason": 10985 if value != nil { 10986 jtv, ok := value.(string) 10987 if !ok { 10988 return fmt.Errorf("expected LastUpdateStatusReason to be of type string, got %T instead", value) 10989 } 10990 sv.LastUpdateStatusReason = ptr.String(jtv) 10991 } 10992 10993 case "LastUpdateStatusReasonCode": 10994 if value != nil { 10995 jtv, ok := value.(string) 10996 if !ok { 10997 return fmt.Errorf("expected LastUpdateStatusReasonCode to be of type string, got %T instead", value) 10998 } 10999 sv.LastUpdateStatusReasonCode = types.LastUpdateStatusReasonCode(jtv) 11000 } 11001 11002 case "Layers": 11003 if err := awsRestjson1_deserializeDocumentLayersReferenceList(&sv.Layers, value); err != nil { 11004 return err 11005 } 11006 11007 case "MasterArn": 11008 if value != nil { 11009 jtv, ok := value.(string) 11010 if !ok { 11011 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 11012 } 11013 sv.MasterArn = ptr.String(jtv) 11014 } 11015 11016 case "MemorySize": 11017 if value != nil { 11018 jtv, ok := value.(json.Number) 11019 if !ok { 11020 return fmt.Errorf("expected MemorySize to be json.Number, got %T instead", value) 11021 } 11022 i64, err := jtv.Int64() 11023 if err != nil { 11024 return err 11025 } 11026 sv.MemorySize = ptr.Int32(int32(i64)) 11027 } 11028 11029 case "PackageType": 11030 if value != nil { 11031 jtv, ok := value.(string) 11032 if !ok { 11033 return fmt.Errorf("expected PackageType to be of type string, got %T instead", value) 11034 } 11035 sv.PackageType = types.PackageType(jtv) 11036 } 11037 11038 case "RevisionId": 11039 if value != nil { 11040 jtv, ok := value.(string) 11041 if !ok { 11042 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11043 } 11044 sv.RevisionId = ptr.String(jtv) 11045 } 11046 11047 case "Role": 11048 if value != nil { 11049 jtv, ok := value.(string) 11050 if !ok { 11051 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 11052 } 11053 sv.Role = ptr.String(jtv) 11054 } 11055 11056 case "Runtime": 11057 if value != nil { 11058 jtv, ok := value.(string) 11059 if !ok { 11060 return fmt.Errorf("expected Runtime to be of type string, got %T instead", value) 11061 } 11062 sv.Runtime = types.Runtime(jtv) 11063 } 11064 11065 case "SigningJobArn": 11066 if value != nil { 11067 jtv, ok := value.(string) 11068 if !ok { 11069 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 11070 } 11071 sv.SigningJobArn = ptr.String(jtv) 11072 } 11073 11074 case "SigningProfileVersionArn": 11075 if value != nil { 11076 jtv, ok := value.(string) 11077 if !ok { 11078 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 11079 } 11080 sv.SigningProfileVersionArn = ptr.String(jtv) 11081 } 11082 11083 case "State": 11084 if value != nil { 11085 jtv, ok := value.(string) 11086 if !ok { 11087 return fmt.Errorf("expected State to be of type string, got %T instead", value) 11088 } 11089 sv.State = types.State(jtv) 11090 } 11091 11092 case "StateReason": 11093 if value != nil { 11094 jtv, ok := value.(string) 11095 if !ok { 11096 return fmt.Errorf("expected StateReason to be of type string, got %T instead", value) 11097 } 11098 sv.StateReason = ptr.String(jtv) 11099 } 11100 11101 case "StateReasonCode": 11102 if value != nil { 11103 jtv, ok := value.(string) 11104 if !ok { 11105 return fmt.Errorf("expected StateReasonCode to be of type string, got %T instead", value) 11106 } 11107 sv.StateReasonCode = types.StateReasonCode(jtv) 11108 } 11109 11110 case "Timeout": 11111 if value != nil { 11112 jtv, ok := value.(json.Number) 11113 if !ok { 11114 return fmt.Errorf("expected Timeout to be json.Number, got %T instead", value) 11115 } 11116 i64, err := jtv.Int64() 11117 if err != nil { 11118 return err 11119 } 11120 sv.Timeout = ptr.Int32(int32(i64)) 11121 } 11122 11123 case "TracingConfig": 11124 if err := awsRestjson1_deserializeDocumentTracingConfigResponse(&sv.TracingConfig, value); err != nil { 11125 return err 11126 } 11127 11128 case "Version": 11129 if value != nil { 11130 jtv, ok := value.(string) 11131 if !ok { 11132 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 11133 } 11134 sv.Version = ptr.String(jtv) 11135 } 11136 11137 case "VpcConfig": 11138 if err := awsRestjson1_deserializeDocumentVpcConfigResponse(&sv.VpcConfig, value); err != nil { 11139 return err 11140 } 11141 11142 default: 11143 _, _ = key, value 11144 11145 } 11146 } 11147 *v = sv 11148 return nil 11149} 11150 11151type awsRestjson1_deserializeOpUpdateFunctionEventInvokeConfig struct { 11152} 11153 11154func (*awsRestjson1_deserializeOpUpdateFunctionEventInvokeConfig) ID() string { 11155 return "OperationDeserializer" 11156} 11157 11158func (m *awsRestjson1_deserializeOpUpdateFunctionEventInvokeConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 11159 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 11160) { 11161 out, metadata, err = next.HandleDeserialize(ctx, in) 11162 if err != nil { 11163 return out, metadata, err 11164 } 11165 11166 response, ok := out.RawResponse.(*smithyhttp.Response) 11167 if !ok { 11168 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11169 } 11170 11171 if response.StatusCode < 200 || response.StatusCode >= 300 { 11172 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFunctionEventInvokeConfig(response, &metadata) 11173 } 11174 output := &UpdateFunctionEventInvokeConfigOutput{} 11175 out.Result = output 11176 11177 var buff [1024]byte 11178 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11179 11180 body := io.TeeReader(response.Body, ringBuffer) 11181 11182 decoder := json.NewDecoder(body) 11183 decoder.UseNumber() 11184 var shape interface{} 11185 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11186 var snapshot bytes.Buffer 11187 io.Copy(&snapshot, ringBuffer) 11188 err = &smithy.DeserializationError{ 11189 Err: fmt.Errorf("failed to decode response body, %w", err), 11190 Snapshot: snapshot.Bytes(), 11191 } 11192 return out, metadata, err 11193 } 11194 11195 err = awsRestjson1_deserializeOpDocumentUpdateFunctionEventInvokeConfigOutput(&output, shape) 11196 if err != nil { 11197 var snapshot bytes.Buffer 11198 io.Copy(&snapshot, ringBuffer) 11199 return out, metadata, &smithy.DeserializationError{ 11200 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 11201 Snapshot: snapshot.Bytes(), 11202 } 11203 } 11204 11205 return out, metadata, err 11206} 11207 11208func awsRestjson1_deserializeOpErrorUpdateFunctionEventInvokeConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11209 var errorBuffer bytes.Buffer 11210 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11211 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11212 } 11213 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11214 11215 errorCode := "UnknownError" 11216 errorMessage := errorCode 11217 11218 code := response.Header.Get("X-Amzn-ErrorType") 11219 if len(code) != 0 { 11220 errorCode = restjson.SanitizeErrorCode(code) 11221 } 11222 11223 var buff [1024]byte 11224 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11225 11226 body := io.TeeReader(errorBody, ringBuffer) 11227 decoder := json.NewDecoder(body) 11228 decoder.UseNumber() 11229 code, message, err := restjson.GetErrorInfo(decoder) 11230 if err != nil { 11231 var snapshot bytes.Buffer 11232 io.Copy(&snapshot, ringBuffer) 11233 err = &smithy.DeserializationError{ 11234 Err: fmt.Errorf("failed to decode response body, %w", err), 11235 Snapshot: snapshot.Bytes(), 11236 } 11237 return err 11238 } 11239 11240 errorBody.Seek(0, io.SeekStart) 11241 if len(code) != 0 { 11242 errorCode = restjson.SanitizeErrorCode(code) 11243 } 11244 if len(message) != 0 { 11245 errorMessage = message 11246 } 11247 11248 switch { 11249 case strings.EqualFold("InvalidParameterValueException", errorCode): 11250 return awsRestjson1_deserializeErrorInvalidParameterValueException(response, errorBody) 11251 11252 case strings.EqualFold("ResourceNotFoundException", errorCode): 11253 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 11254 11255 case strings.EqualFold("ServiceException", errorCode): 11256 return awsRestjson1_deserializeErrorServiceException(response, errorBody) 11257 11258 case strings.EqualFold("TooManyRequestsException", errorCode): 11259 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 11260 11261 default: 11262 genericError := &smithy.GenericAPIError{ 11263 Code: errorCode, 11264 Message: errorMessage, 11265 } 11266 return genericError 11267 11268 } 11269} 11270 11271func awsRestjson1_deserializeOpDocumentUpdateFunctionEventInvokeConfigOutput(v **UpdateFunctionEventInvokeConfigOutput, value interface{}) error { 11272 if v == nil { 11273 return fmt.Errorf("unexpected nil of type %T", v) 11274 } 11275 if value == nil { 11276 return nil 11277 } 11278 11279 shape, ok := value.(map[string]interface{}) 11280 if !ok { 11281 return fmt.Errorf("unexpected JSON type %v", value) 11282 } 11283 11284 var sv *UpdateFunctionEventInvokeConfigOutput 11285 if *v == nil { 11286 sv = &UpdateFunctionEventInvokeConfigOutput{} 11287 } else { 11288 sv = *v 11289 } 11290 11291 for key, value := range shape { 11292 switch key { 11293 case "DestinationConfig": 11294 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 11295 return err 11296 } 11297 11298 case "FunctionArn": 11299 if value != nil { 11300 jtv, ok := value.(string) 11301 if !ok { 11302 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 11303 } 11304 sv.FunctionArn = ptr.String(jtv) 11305 } 11306 11307 case "LastModified": 11308 if value != nil { 11309 jtv, ok := value.(json.Number) 11310 if !ok { 11311 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 11312 } 11313 f64, err := jtv.Float64() 11314 if err != nil { 11315 return err 11316 } 11317 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11318 } 11319 11320 case "MaximumEventAgeInSeconds": 11321 if value != nil { 11322 jtv, ok := value.(json.Number) 11323 if !ok { 11324 return fmt.Errorf("expected MaximumEventAgeInSeconds to be json.Number, got %T instead", value) 11325 } 11326 i64, err := jtv.Int64() 11327 if err != nil { 11328 return err 11329 } 11330 sv.MaximumEventAgeInSeconds = ptr.Int32(int32(i64)) 11331 } 11332 11333 case "MaximumRetryAttempts": 11334 if value != nil { 11335 jtv, ok := value.(json.Number) 11336 if !ok { 11337 return fmt.Errorf("expected MaximumRetryAttempts to be json.Number, got %T instead", value) 11338 } 11339 i64, err := jtv.Int64() 11340 if err != nil { 11341 return err 11342 } 11343 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 11344 } 11345 11346 default: 11347 _, _ = key, value 11348 11349 } 11350 } 11351 *v = sv 11352 return nil 11353} 11354 11355func awsRestjson1_deserializeOpHttpBindingsTooManyRequestsException(v *types.TooManyRequestsException, response *smithyhttp.Response) error { 11356 if v == nil { 11357 return fmt.Errorf("unsupported deserialization for nil %T", v) 11358 } 11359 11360 if headerValues := response.Header.Values("Retry-After"); len(headerValues) != 0 { 11361 headerValues[0] = strings.TrimSpace(headerValues[0]) 11362 v.RetryAfterSeconds = ptr.String(headerValues[0]) 11363 } 11364 11365 return nil 11366} 11367func awsRestjson1_deserializeErrorCodeSigningConfigNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11368 output := &types.CodeSigningConfigNotFoundException{} 11369 var buff [1024]byte 11370 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11371 11372 body := io.TeeReader(errorBody, ringBuffer) 11373 decoder := json.NewDecoder(body) 11374 decoder.UseNumber() 11375 var shape interface{} 11376 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11377 var snapshot bytes.Buffer 11378 io.Copy(&snapshot, ringBuffer) 11379 err = &smithy.DeserializationError{ 11380 Err: fmt.Errorf("failed to decode response body, %w", err), 11381 Snapshot: snapshot.Bytes(), 11382 } 11383 return err 11384 } 11385 11386 err := awsRestjson1_deserializeDocumentCodeSigningConfigNotFoundException(&output, shape) 11387 11388 if err != nil { 11389 var snapshot bytes.Buffer 11390 io.Copy(&snapshot, ringBuffer) 11391 err = &smithy.DeserializationError{ 11392 Err: fmt.Errorf("failed to decode response body, %w", err), 11393 Snapshot: snapshot.Bytes(), 11394 } 11395 return err 11396 } 11397 11398 errorBody.Seek(0, io.SeekStart) 11399 11400 return output 11401} 11402 11403func awsRestjson1_deserializeErrorCodeStorageExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11404 output := &types.CodeStorageExceededException{} 11405 var buff [1024]byte 11406 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11407 11408 body := io.TeeReader(errorBody, ringBuffer) 11409 decoder := json.NewDecoder(body) 11410 decoder.UseNumber() 11411 var shape interface{} 11412 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11413 var snapshot bytes.Buffer 11414 io.Copy(&snapshot, ringBuffer) 11415 err = &smithy.DeserializationError{ 11416 Err: fmt.Errorf("failed to decode response body, %w", err), 11417 Snapshot: snapshot.Bytes(), 11418 } 11419 return err 11420 } 11421 11422 err := awsRestjson1_deserializeDocumentCodeStorageExceededException(&output, shape) 11423 11424 if err != nil { 11425 var snapshot bytes.Buffer 11426 io.Copy(&snapshot, ringBuffer) 11427 err = &smithy.DeserializationError{ 11428 Err: fmt.Errorf("failed to decode response body, %w", err), 11429 Snapshot: snapshot.Bytes(), 11430 } 11431 return err 11432 } 11433 11434 errorBody.Seek(0, io.SeekStart) 11435 11436 return output 11437} 11438 11439func awsRestjson1_deserializeErrorCodeVerificationFailedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11440 output := &types.CodeVerificationFailedException{} 11441 var buff [1024]byte 11442 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11443 11444 body := io.TeeReader(errorBody, ringBuffer) 11445 decoder := json.NewDecoder(body) 11446 decoder.UseNumber() 11447 var shape interface{} 11448 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11449 var snapshot bytes.Buffer 11450 io.Copy(&snapshot, ringBuffer) 11451 err = &smithy.DeserializationError{ 11452 Err: fmt.Errorf("failed to decode response body, %w", err), 11453 Snapshot: snapshot.Bytes(), 11454 } 11455 return err 11456 } 11457 11458 err := awsRestjson1_deserializeDocumentCodeVerificationFailedException(&output, shape) 11459 11460 if err != nil { 11461 var snapshot bytes.Buffer 11462 io.Copy(&snapshot, ringBuffer) 11463 err = &smithy.DeserializationError{ 11464 Err: fmt.Errorf("failed to decode response body, %w", err), 11465 Snapshot: snapshot.Bytes(), 11466 } 11467 return err 11468 } 11469 11470 errorBody.Seek(0, io.SeekStart) 11471 11472 return output 11473} 11474 11475func awsRestjson1_deserializeErrorEC2AccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11476 output := &types.EC2AccessDeniedException{} 11477 var buff [1024]byte 11478 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11479 11480 body := io.TeeReader(errorBody, ringBuffer) 11481 decoder := json.NewDecoder(body) 11482 decoder.UseNumber() 11483 var shape interface{} 11484 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11485 var snapshot bytes.Buffer 11486 io.Copy(&snapshot, ringBuffer) 11487 err = &smithy.DeserializationError{ 11488 Err: fmt.Errorf("failed to decode response body, %w", err), 11489 Snapshot: snapshot.Bytes(), 11490 } 11491 return err 11492 } 11493 11494 err := awsRestjson1_deserializeDocumentEC2AccessDeniedException(&output, shape) 11495 11496 if err != nil { 11497 var snapshot bytes.Buffer 11498 io.Copy(&snapshot, ringBuffer) 11499 err = &smithy.DeserializationError{ 11500 Err: fmt.Errorf("failed to decode response body, %w", err), 11501 Snapshot: snapshot.Bytes(), 11502 } 11503 return err 11504 } 11505 11506 errorBody.Seek(0, io.SeekStart) 11507 11508 return output 11509} 11510 11511func awsRestjson1_deserializeErrorEC2ThrottledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11512 output := &types.EC2ThrottledException{} 11513 var buff [1024]byte 11514 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11515 11516 body := io.TeeReader(errorBody, ringBuffer) 11517 decoder := json.NewDecoder(body) 11518 decoder.UseNumber() 11519 var shape interface{} 11520 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11521 var snapshot bytes.Buffer 11522 io.Copy(&snapshot, ringBuffer) 11523 err = &smithy.DeserializationError{ 11524 Err: fmt.Errorf("failed to decode response body, %w", err), 11525 Snapshot: snapshot.Bytes(), 11526 } 11527 return err 11528 } 11529 11530 err := awsRestjson1_deserializeDocumentEC2ThrottledException(&output, shape) 11531 11532 if err != nil { 11533 var snapshot bytes.Buffer 11534 io.Copy(&snapshot, ringBuffer) 11535 err = &smithy.DeserializationError{ 11536 Err: fmt.Errorf("failed to decode response body, %w", err), 11537 Snapshot: snapshot.Bytes(), 11538 } 11539 return err 11540 } 11541 11542 errorBody.Seek(0, io.SeekStart) 11543 11544 return output 11545} 11546 11547func awsRestjson1_deserializeErrorEC2UnexpectedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11548 output := &types.EC2UnexpectedException{} 11549 var buff [1024]byte 11550 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11551 11552 body := io.TeeReader(errorBody, ringBuffer) 11553 decoder := json.NewDecoder(body) 11554 decoder.UseNumber() 11555 var shape interface{} 11556 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11557 var snapshot bytes.Buffer 11558 io.Copy(&snapshot, ringBuffer) 11559 err = &smithy.DeserializationError{ 11560 Err: fmt.Errorf("failed to decode response body, %w", err), 11561 Snapshot: snapshot.Bytes(), 11562 } 11563 return err 11564 } 11565 11566 err := awsRestjson1_deserializeDocumentEC2UnexpectedException(&output, shape) 11567 11568 if err != nil { 11569 var snapshot bytes.Buffer 11570 io.Copy(&snapshot, ringBuffer) 11571 err = &smithy.DeserializationError{ 11572 Err: fmt.Errorf("failed to decode response body, %w", err), 11573 Snapshot: snapshot.Bytes(), 11574 } 11575 return err 11576 } 11577 11578 errorBody.Seek(0, io.SeekStart) 11579 11580 return output 11581} 11582 11583func awsRestjson1_deserializeErrorEFSIOException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11584 output := &types.EFSIOException{} 11585 var buff [1024]byte 11586 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11587 11588 body := io.TeeReader(errorBody, ringBuffer) 11589 decoder := json.NewDecoder(body) 11590 decoder.UseNumber() 11591 var shape interface{} 11592 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11593 var snapshot bytes.Buffer 11594 io.Copy(&snapshot, ringBuffer) 11595 err = &smithy.DeserializationError{ 11596 Err: fmt.Errorf("failed to decode response body, %w", err), 11597 Snapshot: snapshot.Bytes(), 11598 } 11599 return err 11600 } 11601 11602 err := awsRestjson1_deserializeDocumentEFSIOException(&output, shape) 11603 11604 if err != nil { 11605 var snapshot bytes.Buffer 11606 io.Copy(&snapshot, ringBuffer) 11607 err = &smithy.DeserializationError{ 11608 Err: fmt.Errorf("failed to decode response body, %w", err), 11609 Snapshot: snapshot.Bytes(), 11610 } 11611 return err 11612 } 11613 11614 errorBody.Seek(0, io.SeekStart) 11615 11616 return output 11617} 11618 11619func awsRestjson1_deserializeErrorEFSMountConnectivityException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11620 output := &types.EFSMountConnectivityException{} 11621 var buff [1024]byte 11622 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11623 11624 body := io.TeeReader(errorBody, ringBuffer) 11625 decoder := json.NewDecoder(body) 11626 decoder.UseNumber() 11627 var shape interface{} 11628 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11629 var snapshot bytes.Buffer 11630 io.Copy(&snapshot, ringBuffer) 11631 err = &smithy.DeserializationError{ 11632 Err: fmt.Errorf("failed to decode response body, %w", err), 11633 Snapshot: snapshot.Bytes(), 11634 } 11635 return err 11636 } 11637 11638 err := awsRestjson1_deserializeDocumentEFSMountConnectivityException(&output, shape) 11639 11640 if err != nil { 11641 var snapshot bytes.Buffer 11642 io.Copy(&snapshot, ringBuffer) 11643 err = &smithy.DeserializationError{ 11644 Err: fmt.Errorf("failed to decode response body, %w", err), 11645 Snapshot: snapshot.Bytes(), 11646 } 11647 return err 11648 } 11649 11650 errorBody.Seek(0, io.SeekStart) 11651 11652 return output 11653} 11654 11655func awsRestjson1_deserializeErrorEFSMountFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11656 output := &types.EFSMountFailureException{} 11657 var buff [1024]byte 11658 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11659 11660 body := io.TeeReader(errorBody, ringBuffer) 11661 decoder := json.NewDecoder(body) 11662 decoder.UseNumber() 11663 var shape interface{} 11664 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11665 var snapshot bytes.Buffer 11666 io.Copy(&snapshot, ringBuffer) 11667 err = &smithy.DeserializationError{ 11668 Err: fmt.Errorf("failed to decode response body, %w", err), 11669 Snapshot: snapshot.Bytes(), 11670 } 11671 return err 11672 } 11673 11674 err := awsRestjson1_deserializeDocumentEFSMountFailureException(&output, shape) 11675 11676 if err != nil { 11677 var snapshot bytes.Buffer 11678 io.Copy(&snapshot, ringBuffer) 11679 err = &smithy.DeserializationError{ 11680 Err: fmt.Errorf("failed to decode response body, %w", err), 11681 Snapshot: snapshot.Bytes(), 11682 } 11683 return err 11684 } 11685 11686 errorBody.Seek(0, io.SeekStart) 11687 11688 return output 11689} 11690 11691func awsRestjson1_deserializeErrorEFSMountTimeoutException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11692 output := &types.EFSMountTimeoutException{} 11693 var buff [1024]byte 11694 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11695 11696 body := io.TeeReader(errorBody, ringBuffer) 11697 decoder := json.NewDecoder(body) 11698 decoder.UseNumber() 11699 var shape interface{} 11700 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11701 var snapshot bytes.Buffer 11702 io.Copy(&snapshot, ringBuffer) 11703 err = &smithy.DeserializationError{ 11704 Err: fmt.Errorf("failed to decode response body, %w", err), 11705 Snapshot: snapshot.Bytes(), 11706 } 11707 return err 11708 } 11709 11710 err := awsRestjson1_deserializeDocumentEFSMountTimeoutException(&output, shape) 11711 11712 if err != nil { 11713 var snapshot bytes.Buffer 11714 io.Copy(&snapshot, ringBuffer) 11715 err = &smithy.DeserializationError{ 11716 Err: fmt.Errorf("failed to decode response body, %w", err), 11717 Snapshot: snapshot.Bytes(), 11718 } 11719 return err 11720 } 11721 11722 errorBody.Seek(0, io.SeekStart) 11723 11724 return output 11725} 11726 11727func awsRestjson1_deserializeErrorENILimitReachedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11728 output := &types.ENILimitReachedException{} 11729 var buff [1024]byte 11730 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11731 11732 body := io.TeeReader(errorBody, ringBuffer) 11733 decoder := json.NewDecoder(body) 11734 decoder.UseNumber() 11735 var shape interface{} 11736 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11737 var snapshot bytes.Buffer 11738 io.Copy(&snapshot, ringBuffer) 11739 err = &smithy.DeserializationError{ 11740 Err: fmt.Errorf("failed to decode response body, %w", err), 11741 Snapshot: snapshot.Bytes(), 11742 } 11743 return err 11744 } 11745 11746 err := awsRestjson1_deserializeDocumentENILimitReachedException(&output, shape) 11747 11748 if err != nil { 11749 var snapshot bytes.Buffer 11750 io.Copy(&snapshot, ringBuffer) 11751 err = &smithy.DeserializationError{ 11752 Err: fmt.Errorf("failed to decode response body, %w", err), 11753 Snapshot: snapshot.Bytes(), 11754 } 11755 return err 11756 } 11757 11758 errorBody.Seek(0, io.SeekStart) 11759 11760 return output 11761} 11762 11763func awsRestjson1_deserializeErrorInvalidCodeSignatureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11764 output := &types.InvalidCodeSignatureException{} 11765 var buff [1024]byte 11766 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11767 11768 body := io.TeeReader(errorBody, ringBuffer) 11769 decoder := json.NewDecoder(body) 11770 decoder.UseNumber() 11771 var shape interface{} 11772 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11773 var snapshot bytes.Buffer 11774 io.Copy(&snapshot, ringBuffer) 11775 err = &smithy.DeserializationError{ 11776 Err: fmt.Errorf("failed to decode response body, %w", err), 11777 Snapshot: snapshot.Bytes(), 11778 } 11779 return err 11780 } 11781 11782 err := awsRestjson1_deserializeDocumentInvalidCodeSignatureException(&output, shape) 11783 11784 if err != nil { 11785 var snapshot bytes.Buffer 11786 io.Copy(&snapshot, ringBuffer) 11787 err = &smithy.DeserializationError{ 11788 Err: fmt.Errorf("failed to decode response body, %w", err), 11789 Snapshot: snapshot.Bytes(), 11790 } 11791 return err 11792 } 11793 11794 errorBody.Seek(0, io.SeekStart) 11795 11796 return output 11797} 11798 11799func awsRestjson1_deserializeErrorInvalidParameterValueException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11800 output := &types.InvalidParameterValueException{} 11801 var buff [1024]byte 11802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11803 11804 body := io.TeeReader(errorBody, ringBuffer) 11805 decoder := json.NewDecoder(body) 11806 decoder.UseNumber() 11807 var shape interface{} 11808 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11809 var snapshot bytes.Buffer 11810 io.Copy(&snapshot, ringBuffer) 11811 err = &smithy.DeserializationError{ 11812 Err: fmt.Errorf("failed to decode response body, %w", err), 11813 Snapshot: snapshot.Bytes(), 11814 } 11815 return err 11816 } 11817 11818 err := awsRestjson1_deserializeDocumentInvalidParameterValueException(&output, shape) 11819 11820 if err != nil { 11821 var snapshot bytes.Buffer 11822 io.Copy(&snapshot, ringBuffer) 11823 err = &smithy.DeserializationError{ 11824 Err: fmt.Errorf("failed to decode response body, %w", err), 11825 Snapshot: snapshot.Bytes(), 11826 } 11827 return err 11828 } 11829 11830 errorBody.Seek(0, io.SeekStart) 11831 11832 return output 11833} 11834 11835func awsRestjson1_deserializeErrorInvalidRequestContentException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11836 output := &types.InvalidRequestContentException{} 11837 var buff [1024]byte 11838 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11839 11840 body := io.TeeReader(errorBody, ringBuffer) 11841 decoder := json.NewDecoder(body) 11842 decoder.UseNumber() 11843 var shape interface{} 11844 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11845 var snapshot bytes.Buffer 11846 io.Copy(&snapshot, ringBuffer) 11847 err = &smithy.DeserializationError{ 11848 Err: fmt.Errorf("failed to decode response body, %w", err), 11849 Snapshot: snapshot.Bytes(), 11850 } 11851 return err 11852 } 11853 11854 err := awsRestjson1_deserializeDocumentInvalidRequestContentException(&output, shape) 11855 11856 if err != nil { 11857 var snapshot bytes.Buffer 11858 io.Copy(&snapshot, ringBuffer) 11859 err = &smithy.DeserializationError{ 11860 Err: fmt.Errorf("failed to decode response body, %w", err), 11861 Snapshot: snapshot.Bytes(), 11862 } 11863 return err 11864 } 11865 11866 errorBody.Seek(0, io.SeekStart) 11867 11868 return output 11869} 11870 11871func awsRestjson1_deserializeErrorInvalidRuntimeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11872 output := &types.InvalidRuntimeException{} 11873 var buff [1024]byte 11874 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11875 11876 body := io.TeeReader(errorBody, ringBuffer) 11877 decoder := json.NewDecoder(body) 11878 decoder.UseNumber() 11879 var shape interface{} 11880 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11881 var snapshot bytes.Buffer 11882 io.Copy(&snapshot, ringBuffer) 11883 err = &smithy.DeserializationError{ 11884 Err: fmt.Errorf("failed to decode response body, %w", err), 11885 Snapshot: snapshot.Bytes(), 11886 } 11887 return err 11888 } 11889 11890 err := awsRestjson1_deserializeDocumentInvalidRuntimeException(&output, shape) 11891 11892 if err != nil { 11893 var snapshot bytes.Buffer 11894 io.Copy(&snapshot, ringBuffer) 11895 err = &smithy.DeserializationError{ 11896 Err: fmt.Errorf("failed to decode response body, %w", err), 11897 Snapshot: snapshot.Bytes(), 11898 } 11899 return err 11900 } 11901 11902 errorBody.Seek(0, io.SeekStart) 11903 11904 return output 11905} 11906 11907func awsRestjson1_deserializeErrorInvalidSecurityGroupIDException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11908 output := &types.InvalidSecurityGroupIDException{} 11909 var buff [1024]byte 11910 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11911 11912 body := io.TeeReader(errorBody, ringBuffer) 11913 decoder := json.NewDecoder(body) 11914 decoder.UseNumber() 11915 var shape interface{} 11916 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11917 var snapshot bytes.Buffer 11918 io.Copy(&snapshot, ringBuffer) 11919 err = &smithy.DeserializationError{ 11920 Err: fmt.Errorf("failed to decode response body, %w", err), 11921 Snapshot: snapshot.Bytes(), 11922 } 11923 return err 11924 } 11925 11926 err := awsRestjson1_deserializeDocumentInvalidSecurityGroupIDException(&output, shape) 11927 11928 if err != nil { 11929 var snapshot bytes.Buffer 11930 io.Copy(&snapshot, ringBuffer) 11931 err = &smithy.DeserializationError{ 11932 Err: fmt.Errorf("failed to decode response body, %w", err), 11933 Snapshot: snapshot.Bytes(), 11934 } 11935 return err 11936 } 11937 11938 errorBody.Seek(0, io.SeekStart) 11939 11940 return output 11941} 11942 11943func awsRestjson1_deserializeErrorInvalidSubnetIDException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11944 output := &types.InvalidSubnetIDException{} 11945 var buff [1024]byte 11946 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11947 11948 body := io.TeeReader(errorBody, ringBuffer) 11949 decoder := json.NewDecoder(body) 11950 decoder.UseNumber() 11951 var shape interface{} 11952 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11953 var snapshot bytes.Buffer 11954 io.Copy(&snapshot, ringBuffer) 11955 err = &smithy.DeserializationError{ 11956 Err: fmt.Errorf("failed to decode response body, %w", err), 11957 Snapshot: snapshot.Bytes(), 11958 } 11959 return err 11960 } 11961 11962 err := awsRestjson1_deserializeDocumentInvalidSubnetIDException(&output, shape) 11963 11964 if err != nil { 11965 var snapshot bytes.Buffer 11966 io.Copy(&snapshot, ringBuffer) 11967 err = &smithy.DeserializationError{ 11968 Err: fmt.Errorf("failed to decode response body, %w", err), 11969 Snapshot: snapshot.Bytes(), 11970 } 11971 return err 11972 } 11973 11974 errorBody.Seek(0, io.SeekStart) 11975 11976 return output 11977} 11978 11979func awsRestjson1_deserializeErrorInvalidZipFileException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11980 output := &types.InvalidZipFileException{} 11981 var buff [1024]byte 11982 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11983 11984 body := io.TeeReader(errorBody, ringBuffer) 11985 decoder := json.NewDecoder(body) 11986 decoder.UseNumber() 11987 var shape interface{} 11988 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11989 var snapshot bytes.Buffer 11990 io.Copy(&snapshot, ringBuffer) 11991 err = &smithy.DeserializationError{ 11992 Err: fmt.Errorf("failed to decode response body, %w", err), 11993 Snapshot: snapshot.Bytes(), 11994 } 11995 return err 11996 } 11997 11998 err := awsRestjson1_deserializeDocumentInvalidZipFileException(&output, shape) 11999 12000 if err != nil { 12001 var snapshot bytes.Buffer 12002 io.Copy(&snapshot, ringBuffer) 12003 err = &smithy.DeserializationError{ 12004 Err: fmt.Errorf("failed to decode response body, %w", err), 12005 Snapshot: snapshot.Bytes(), 12006 } 12007 return err 12008 } 12009 12010 errorBody.Seek(0, io.SeekStart) 12011 12012 return output 12013} 12014 12015func awsRestjson1_deserializeErrorKMSAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12016 output := &types.KMSAccessDeniedException{} 12017 var buff [1024]byte 12018 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12019 12020 body := io.TeeReader(errorBody, ringBuffer) 12021 decoder := json.NewDecoder(body) 12022 decoder.UseNumber() 12023 var shape interface{} 12024 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12025 var snapshot bytes.Buffer 12026 io.Copy(&snapshot, ringBuffer) 12027 err = &smithy.DeserializationError{ 12028 Err: fmt.Errorf("failed to decode response body, %w", err), 12029 Snapshot: snapshot.Bytes(), 12030 } 12031 return err 12032 } 12033 12034 err := awsRestjson1_deserializeDocumentKMSAccessDeniedException(&output, shape) 12035 12036 if err != nil { 12037 var snapshot bytes.Buffer 12038 io.Copy(&snapshot, ringBuffer) 12039 err = &smithy.DeserializationError{ 12040 Err: fmt.Errorf("failed to decode response body, %w", err), 12041 Snapshot: snapshot.Bytes(), 12042 } 12043 return err 12044 } 12045 12046 errorBody.Seek(0, io.SeekStart) 12047 12048 return output 12049} 12050 12051func awsRestjson1_deserializeErrorKMSDisabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12052 output := &types.KMSDisabledException{} 12053 var buff [1024]byte 12054 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12055 12056 body := io.TeeReader(errorBody, ringBuffer) 12057 decoder := json.NewDecoder(body) 12058 decoder.UseNumber() 12059 var shape interface{} 12060 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12061 var snapshot bytes.Buffer 12062 io.Copy(&snapshot, ringBuffer) 12063 err = &smithy.DeserializationError{ 12064 Err: fmt.Errorf("failed to decode response body, %w", err), 12065 Snapshot: snapshot.Bytes(), 12066 } 12067 return err 12068 } 12069 12070 err := awsRestjson1_deserializeDocumentKMSDisabledException(&output, shape) 12071 12072 if err != nil { 12073 var snapshot bytes.Buffer 12074 io.Copy(&snapshot, ringBuffer) 12075 err = &smithy.DeserializationError{ 12076 Err: fmt.Errorf("failed to decode response body, %w", err), 12077 Snapshot: snapshot.Bytes(), 12078 } 12079 return err 12080 } 12081 12082 errorBody.Seek(0, io.SeekStart) 12083 12084 return output 12085} 12086 12087func awsRestjson1_deserializeErrorKMSInvalidStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12088 output := &types.KMSInvalidStateException{} 12089 var buff [1024]byte 12090 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12091 12092 body := io.TeeReader(errorBody, ringBuffer) 12093 decoder := json.NewDecoder(body) 12094 decoder.UseNumber() 12095 var shape interface{} 12096 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12097 var snapshot bytes.Buffer 12098 io.Copy(&snapshot, ringBuffer) 12099 err = &smithy.DeserializationError{ 12100 Err: fmt.Errorf("failed to decode response body, %w", err), 12101 Snapshot: snapshot.Bytes(), 12102 } 12103 return err 12104 } 12105 12106 err := awsRestjson1_deserializeDocumentKMSInvalidStateException(&output, shape) 12107 12108 if err != nil { 12109 var snapshot bytes.Buffer 12110 io.Copy(&snapshot, ringBuffer) 12111 err = &smithy.DeserializationError{ 12112 Err: fmt.Errorf("failed to decode response body, %w", err), 12113 Snapshot: snapshot.Bytes(), 12114 } 12115 return err 12116 } 12117 12118 errorBody.Seek(0, io.SeekStart) 12119 12120 return output 12121} 12122 12123func awsRestjson1_deserializeErrorKMSNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12124 output := &types.KMSNotFoundException{} 12125 var buff [1024]byte 12126 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12127 12128 body := io.TeeReader(errorBody, ringBuffer) 12129 decoder := json.NewDecoder(body) 12130 decoder.UseNumber() 12131 var shape interface{} 12132 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12133 var snapshot bytes.Buffer 12134 io.Copy(&snapshot, ringBuffer) 12135 err = &smithy.DeserializationError{ 12136 Err: fmt.Errorf("failed to decode response body, %w", err), 12137 Snapshot: snapshot.Bytes(), 12138 } 12139 return err 12140 } 12141 12142 err := awsRestjson1_deserializeDocumentKMSNotFoundException(&output, shape) 12143 12144 if err != nil { 12145 var snapshot bytes.Buffer 12146 io.Copy(&snapshot, ringBuffer) 12147 err = &smithy.DeserializationError{ 12148 Err: fmt.Errorf("failed to decode response body, %w", err), 12149 Snapshot: snapshot.Bytes(), 12150 } 12151 return err 12152 } 12153 12154 errorBody.Seek(0, io.SeekStart) 12155 12156 return output 12157} 12158 12159func awsRestjson1_deserializeErrorPolicyLengthExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12160 output := &types.PolicyLengthExceededException{} 12161 var buff [1024]byte 12162 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12163 12164 body := io.TeeReader(errorBody, ringBuffer) 12165 decoder := json.NewDecoder(body) 12166 decoder.UseNumber() 12167 var shape interface{} 12168 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12169 var snapshot bytes.Buffer 12170 io.Copy(&snapshot, ringBuffer) 12171 err = &smithy.DeserializationError{ 12172 Err: fmt.Errorf("failed to decode response body, %w", err), 12173 Snapshot: snapshot.Bytes(), 12174 } 12175 return err 12176 } 12177 12178 err := awsRestjson1_deserializeDocumentPolicyLengthExceededException(&output, shape) 12179 12180 if err != nil { 12181 var snapshot bytes.Buffer 12182 io.Copy(&snapshot, ringBuffer) 12183 err = &smithy.DeserializationError{ 12184 Err: fmt.Errorf("failed to decode response body, %w", err), 12185 Snapshot: snapshot.Bytes(), 12186 } 12187 return err 12188 } 12189 12190 errorBody.Seek(0, io.SeekStart) 12191 12192 return output 12193} 12194 12195func awsRestjson1_deserializeErrorPreconditionFailedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12196 output := &types.PreconditionFailedException{} 12197 var buff [1024]byte 12198 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12199 12200 body := io.TeeReader(errorBody, ringBuffer) 12201 decoder := json.NewDecoder(body) 12202 decoder.UseNumber() 12203 var shape interface{} 12204 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12205 var snapshot bytes.Buffer 12206 io.Copy(&snapshot, ringBuffer) 12207 err = &smithy.DeserializationError{ 12208 Err: fmt.Errorf("failed to decode response body, %w", err), 12209 Snapshot: snapshot.Bytes(), 12210 } 12211 return err 12212 } 12213 12214 err := awsRestjson1_deserializeDocumentPreconditionFailedException(&output, shape) 12215 12216 if err != nil { 12217 var snapshot bytes.Buffer 12218 io.Copy(&snapshot, ringBuffer) 12219 err = &smithy.DeserializationError{ 12220 Err: fmt.Errorf("failed to decode response body, %w", err), 12221 Snapshot: snapshot.Bytes(), 12222 } 12223 return err 12224 } 12225 12226 errorBody.Seek(0, io.SeekStart) 12227 12228 return output 12229} 12230 12231func awsRestjson1_deserializeErrorProvisionedConcurrencyConfigNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12232 output := &types.ProvisionedConcurrencyConfigNotFoundException{} 12233 var buff [1024]byte 12234 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12235 12236 body := io.TeeReader(errorBody, ringBuffer) 12237 decoder := json.NewDecoder(body) 12238 decoder.UseNumber() 12239 var shape interface{} 12240 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12241 var snapshot bytes.Buffer 12242 io.Copy(&snapshot, ringBuffer) 12243 err = &smithy.DeserializationError{ 12244 Err: fmt.Errorf("failed to decode response body, %w", err), 12245 Snapshot: snapshot.Bytes(), 12246 } 12247 return err 12248 } 12249 12250 err := awsRestjson1_deserializeDocumentProvisionedConcurrencyConfigNotFoundException(&output, shape) 12251 12252 if err != nil { 12253 var snapshot bytes.Buffer 12254 io.Copy(&snapshot, ringBuffer) 12255 err = &smithy.DeserializationError{ 12256 Err: fmt.Errorf("failed to decode response body, %w", err), 12257 Snapshot: snapshot.Bytes(), 12258 } 12259 return err 12260 } 12261 12262 errorBody.Seek(0, io.SeekStart) 12263 12264 return output 12265} 12266 12267func awsRestjson1_deserializeErrorRequestTooLargeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12268 output := &types.RequestTooLargeException{} 12269 var buff [1024]byte 12270 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12271 12272 body := io.TeeReader(errorBody, ringBuffer) 12273 decoder := json.NewDecoder(body) 12274 decoder.UseNumber() 12275 var shape interface{} 12276 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12277 var snapshot bytes.Buffer 12278 io.Copy(&snapshot, ringBuffer) 12279 err = &smithy.DeserializationError{ 12280 Err: fmt.Errorf("failed to decode response body, %w", err), 12281 Snapshot: snapshot.Bytes(), 12282 } 12283 return err 12284 } 12285 12286 err := awsRestjson1_deserializeDocumentRequestTooLargeException(&output, shape) 12287 12288 if err != nil { 12289 var snapshot bytes.Buffer 12290 io.Copy(&snapshot, ringBuffer) 12291 err = &smithy.DeserializationError{ 12292 Err: fmt.Errorf("failed to decode response body, %w", err), 12293 Snapshot: snapshot.Bytes(), 12294 } 12295 return err 12296 } 12297 12298 errorBody.Seek(0, io.SeekStart) 12299 12300 return output 12301} 12302 12303func awsRestjson1_deserializeErrorResourceConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12304 output := &types.ResourceConflictException{} 12305 var buff [1024]byte 12306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12307 12308 body := io.TeeReader(errorBody, ringBuffer) 12309 decoder := json.NewDecoder(body) 12310 decoder.UseNumber() 12311 var shape interface{} 12312 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12313 var snapshot bytes.Buffer 12314 io.Copy(&snapshot, ringBuffer) 12315 err = &smithy.DeserializationError{ 12316 Err: fmt.Errorf("failed to decode response body, %w", err), 12317 Snapshot: snapshot.Bytes(), 12318 } 12319 return err 12320 } 12321 12322 err := awsRestjson1_deserializeDocumentResourceConflictException(&output, shape) 12323 12324 if err != nil { 12325 var snapshot bytes.Buffer 12326 io.Copy(&snapshot, ringBuffer) 12327 err = &smithy.DeserializationError{ 12328 Err: fmt.Errorf("failed to decode response body, %w", err), 12329 Snapshot: snapshot.Bytes(), 12330 } 12331 return err 12332 } 12333 12334 errorBody.Seek(0, io.SeekStart) 12335 12336 return output 12337} 12338 12339func awsRestjson1_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12340 output := &types.ResourceInUseException{} 12341 var buff [1024]byte 12342 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12343 12344 body := io.TeeReader(errorBody, ringBuffer) 12345 decoder := json.NewDecoder(body) 12346 decoder.UseNumber() 12347 var shape interface{} 12348 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12349 var snapshot bytes.Buffer 12350 io.Copy(&snapshot, ringBuffer) 12351 err = &smithy.DeserializationError{ 12352 Err: fmt.Errorf("failed to decode response body, %w", err), 12353 Snapshot: snapshot.Bytes(), 12354 } 12355 return err 12356 } 12357 12358 err := awsRestjson1_deserializeDocumentResourceInUseException(&output, shape) 12359 12360 if err != nil { 12361 var snapshot bytes.Buffer 12362 io.Copy(&snapshot, ringBuffer) 12363 err = &smithy.DeserializationError{ 12364 Err: fmt.Errorf("failed to decode response body, %w", err), 12365 Snapshot: snapshot.Bytes(), 12366 } 12367 return err 12368 } 12369 12370 errorBody.Seek(0, io.SeekStart) 12371 12372 return output 12373} 12374 12375func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12376 output := &types.ResourceNotFoundException{} 12377 var buff [1024]byte 12378 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12379 12380 body := io.TeeReader(errorBody, ringBuffer) 12381 decoder := json.NewDecoder(body) 12382 decoder.UseNumber() 12383 var shape interface{} 12384 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12385 var snapshot bytes.Buffer 12386 io.Copy(&snapshot, ringBuffer) 12387 err = &smithy.DeserializationError{ 12388 Err: fmt.Errorf("failed to decode response body, %w", err), 12389 Snapshot: snapshot.Bytes(), 12390 } 12391 return err 12392 } 12393 12394 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 12395 12396 if err != nil { 12397 var snapshot bytes.Buffer 12398 io.Copy(&snapshot, ringBuffer) 12399 err = &smithy.DeserializationError{ 12400 Err: fmt.Errorf("failed to decode response body, %w", err), 12401 Snapshot: snapshot.Bytes(), 12402 } 12403 return err 12404 } 12405 12406 errorBody.Seek(0, io.SeekStart) 12407 12408 return output 12409} 12410 12411func awsRestjson1_deserializeErrorResourceNotReadyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12412 output := &types.ResourceNotReadyException{} 12413 var buff [1024]byte 12414 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12415 12416 body := io.TeeReader(errorBody, ringBuffer) 12417 decoder := json.NewDecoder(body) 12418 decoder.UseNumber() 12419 var shape interface{} 12420 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12421 var snapshot bytes.Buffer 12422 io.Copy(&snapshot, ringBuffer) 12423 err = &smithy.DeserializationError{ 12424 Err: fmt.Errorf("failed to decode response body, %w", err), 12425 Snapshot: snapshot.Bytes(), 12426 } 12427 return err 12428 } 12429 12430 err := awsRestjson1_deserializeDocumentResourceNotReadyException(&output, shape) 12431 12432 if err != nil { 12433 var snapshot bytes.Buffer 12434 io.Copy(&snapshot, ringBuffer) 12435 err = &smithy.DeserializationError{ 12436 Err: fmt.Errorf("failed to decode response body, %w", err), 12437 Snapshot: snapshot.Bytes(), 12438 } 12439 return err 12440 } 12441 12442 errorBody.Seek(0, io.SeekStart) 12443 12444 return output 12445} 12446 12447func awsRestjson1_deserializeErrorServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12448 output := &types.ServiceException{} 12449 var buff [1024]byte 12450 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12451 12452 body := io.TeeReader(errorBody, ringBuffer) 12453 decoder := json.NewDecoder(body) 12454 decoder.UseNumber() 12455 var shape interface{} 12456 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12457 var snapshot bytes.Buffer 12458 io.Copy(&snapshot, ringBuffer) 12459 err = &smithy.DeserializationError{ 12460 Err: fmt.Errorf("failed to decode response body, %w", err), 12461 Snapshot: snapshot.Bytes(), 12462 } 12463 return err 12464 } 12465 12466 err := awsRestjson1_deserializeDocumentServiceException(&output, shape) 12467 12468 if err != nil { 12469 var snapshot bytes.Buffer 12470 io.Copy(&snapshot, ringBuffer) 12471 err = &smithy.DeserializationError{ 12472 Err: fmt.Errorf("failed to decode response body, %w", err), 12473 Snapshot: snapshot.Bytes(), 12474 } 12475 return err 12476 } 12477 12478 errorBody.Seek(0, io.SeekStart) 12479 12480 return output 12481} 12482 12483func awsRestjson1_deserializeErrorSubnetIPAddressLimitReachedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12484 output := &types.SubnetIPAddressLimitReachedException{} 12485 var buff [1024]byte 12486 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12487 12488 body := io.TeeReader(errorBody, ringBuffer) 12489 decoder := json.NewDecoder(body) 12490 decoder.UseNumber() 12491 var shape interface{} 12492 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12493 var snapshot bytes.Buffer 12494 io.Copy(&snapshot, ringBuffer) 12495 err = &smithy.DeserializationError{ 12496 Err: fmt.Errorf("failed to decode response body, %w", err), 12497 Snapshot: snapshot.Bytes(), 12498 } 12499 return err 12500 } 12501 12502 err := awsRestjson1_deserializeDocumentSubnetIPAddressLimitReachedException(&output, shape) 12503 12504 if err != nil { 12505 var snapshot bytes.Buffer 12506 io.Copy(&snapshot, ringBuffer) 12507 err = &smithy.DeserializationError{ 12508 Err: fmt.Errorf("failed to decode response body, %w", err), 12509 Snapshot: snapshot.Bytes(), 12510 } 12511 return err 12512 } 12513 12514 errorBody.Seek(0, io.SeekStart) 12515 12516 return output 12517} 12518 12519func awsRestjson1_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12520 output := &types.TooManyRequestsException{} 12521 var buff [1024]byte 12522 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12523 12524 body := io.TeeReader(errorBody, ringBuffer) 12525 decoder := json.NewDecoder(body) 12526 decoder.UseNumber() 12527 var shape interface{} 12528 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12529 var snapshot bytes.Buffer 12530 io.Copy(&snapshot, ringBuffer) 12531 err = &smithy.DeserializationError{ 12532 Err: fmt.Errorf("failed to decode response body, %w", err), 12533 Snapshot: snapshot.Bytes(), 12534 } 12535 return err 12536 } 12537 12538 err := awsRestjson1_deserializeDocumentTooManyRequestsException(&output, shape) 12539 12540 if err != nil { 12541 var snapshot bytes.Buffer 12542 io.Copy(&snapshot, ringBuffer) 12543 err = &smithy.DeserializationError{ 12544 Err: fmt.Errorf("failed to decode response body, %w", err), 12545 Snapshot: snapshot.Bytes(), 12546 } 12547 return err 12548 } 12549 12550 errorBody.Seek(0, io.SeekStart) 12551 12552 if err := awsRestjson1_deserializeOpHttpBindingsTooManyRequestsException(output, response); err != nil { 12553 return &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response error with invalid HTTP bindings, %w", err)} 12554 } 12555 12556 return output 12557} 12558 12559func awsRestjson1_deserializeErrorUnsupportedMediaTypeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12560 output := &types.UnsupportedMediaTypeException{} 12561 var buff [1024]byte 12562 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12563 12564 body := io.TeeReader(errorBody, ringBuffer) 12565 decoder := json.NewDecoder(body) 12566 decoder.UseNumber() 12567 var shape interface{} 12568 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 12569 var snapshot bytes.Buffer 12570 io.Copy(&snapshot, ringBuffer) 12571 err = &smithy.DeserializationError{ 12572 Err: fmt.Errorf("failed to decode response body, %w", err), 12573 Snapshot: snapshot.Bytes(), 12574 } 12575 return err 12576 } 12577 12578 err := awsRestjson1_deserializeDocumentUnsupportedMediaTypeException(&output, shape) 12579 12580 if err != nil { 12581 var snapshot bytes.Buffer 12582 io.Copy(&snapshot, ringBuffer) 12583 err = &smithy.DeserializationError{ 12584 Err: fmt.Errorf("failed to decode response body, %w", err), 12585 Snapshot: snapshot.Bytes(), 12586 } 12587 return err 12588 } 12589 12590 errorBody.Seek(0, io.SeekStart) 12591 12592 return output 12593} 12594 12595func awsRestjson1_deserializeDocumentAccountLimit(v **types.AccountLimit, value interface{}) error { 12596 if v == nil { 12597 return fmt.Errorf("unexpected nil of type %T", v) 12598 } 12599 if value == nil { 12600 return nil 12601 } 12602 12603 shape, ok := value.(map[string]interface{}) 12604 if !ok { 12605 return fmt.Errorf("unexpected JSON type %v", value) 12606 } 12607 12608 var sv *types.AccountLimit 12609 if *v == nil { 12610 sv = &types.AccountLimit{} 12611 } else { 12612 sv = *v 12613 } 12614 12615 for key, value := range shape { 12616 switch key { 12617 case "CodeSizeUnzipped": 12618 if value != nil { 12619 jtv, ok := value.(json.Number) 12620 if !ok { 12621 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 12622 } 12623 i64, err := jtv.Int64() 12624 if err != nil { 12625 return err 12626 } 12627 sv.CodeSizeUnzipped = i64 12628 } 12629 12630 case "CodeSizeZipped": 12631 if value != nil { 12632 jtv, ok := value.(json.Number) 12633 if !ok { 12634 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 12635 } 12636 i64, err := jtv.Int64() 12637 if err != nil { 12638 return err 12639 } 12640 sv.CodeSizeZipped = i64 12641 } 12642 12643 case "ConcurrentExecutions": 12644 if value != nil { 12645 jtv, ok := value.(json.Number) 12646 if !ok { 12647 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 12648 } 12649 i64, err := jtv.Int64() 12650 if err != nil { 12651 return err 12652 } 12653 sv.ConcurrentExecutions = int32(i64) 12654 } 12655 12656 case "TotalCodeSize": 12657 if value != nil { 12658 jtv, ok := value.(json.Number) 12659 if !ok { 12660 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 12661 } 12662 i64, err := jtv.Int64() 12663 if err != nil { 12664 return err 12665 } 12666 sv.TotalCodeSize = i64 12667 } 12668 12669 case "UnreservedConcurrentExecutions": 12670 if value != nil { 12671 jtv, ok := value.(json.Number) 12672 if !ok { 12673 return fmt.Errorf("expected UnreservedConcurrentExecutions to be json.Number, got %T instead", value) 12674 } 12675 i64, err := jtv.Int64() 12676 if err != nil { 12677 return err 12678 } 12679 sv.UnreservedConcurrentExecutions = ptr.Int32(int32(i64)) 12680 } 12681 12682 default: 12683 _, _ = key, value 12684 12685 } 12686 } 12687 *v = sv 12688 return nil 12689} 12690 12691func awsRestjson1_deserializeDocumentAccountUsage(v **types.AccountUsage, value interface{}) error { 12692 if v == nil { 12693 return fmt.Errorf("unexpected nil of type %T", v) 12694 } 12695 if value == nil { 12696 return nil 12697 } 12698 12699 shape, ok := value.(map[string]interface{}) 12700 if !ok { 12701 return fmt.Errorf("unexpected JSON type %v", value) 12702 } 12703 12704 var sv *types.AccountUsage 12705 if *v == nil { 12706 sv = &types.AccountUsage{} 12707 } else { 12708 sv = *v 12709 } 12710 12711 for key, value := range shape { 12712 switch key { 12713 case "FunctionCount": 12714 if value != nil { 12715 jtv, ok := value.(json.Number) 12716 if !ok { 12717 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 12718 } 12719 i64, err := jtv.Int64() 12720 if err != nil { 12721 return err 12722 } 12723 sv.FunctionCount = i64 12724 } 12725 12726 case "TotalCodeSize": 12727 if value != nil { 12728 jtv, ok := value.(json.Number) 12729 if !ok { 12730 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 12731 } 12732 i64, err := jtv.Int64() 12733 if err != nil { 12734 return err 12735 } 12736 sv.TotalCodeSize = i64 12737 } 12738 12739 default: 12740 _, _ = key, value 12741 12742 } 12743 } 12744 *v = sv 12745 return nil 12746} 12747 12748func awsRestjson1_deserializeDocumentAdditionalVersionWeights(v *map[string]float64, value interface{}) error { 12749 if v == nil { 12750 return fmt.Errorf("unexpected nil of type %T", v) 12751 } 12752 if value == nil { 12753 return nil 12754 } 12755 12756 shape, ok := value.(map[string]interface{}) 12757 if !ok { 12758 return fmt.Errorf("unexpected JSON type %v", value) 12759 } 12760 12761 var mv map[string]float64 12762 if *v == nil { 12763 mv = map[string]float64{} 12764 } else { 12765 mv = *v 12766 } 12767 12768 for key, value := range shape { 12769 var parsedVal float64 12770 if value != nil { 12771 jtv, ok := value.(json.Number) 12772 if !ok { 12773 return fmt.Errorf("expected Weight to be json.Number, got %T instead", value) 12774 } 12775 f64, err := jtv.Float64() 12776 if err != nil { 12777 return err 12778 } 12779 parsedVal = f64 12780 } 12781 mv[key] = parsedVal 12782 12783 } 12784 *v = mv 12785 return nil 12786} 12787 12788func awsRestjson1_deserializeDocumentAliasConfiguration(v **types.AliasConfiguration, value interface{}) error { 12789 if v == nil { 12790 return fmt.Errorf("unexpected nil of type %T", v) 12791 } 12792 if value == nil { 12793 return nil 12794 } 12795 12796 shape, ok := value.(map[string]interface{}) 12797 if !ok { 12798 return fmt.Errorf("unexpected JSON type %v", value) 12799 } 12800 12801 var sv *types.AliasConfiguration 12802 if *v == nil { 12803 sv = &types.AliasConfiguration{} 12804 } else { 12805 sv = *v 12806 } 12807 12808 for key, value := range shape { 12809 switch key { 12810 case "AliasArn": 12811 if value != nil { 12812 jtv, ok := value.(string) 12813 if !ok { 12814 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 12815 } 12816 sv.AliasArn = ptr.String(jtv) 12817 } 12818 12819 case "Description": 12820 if value != nil { 12821 jtv, ok := value.(string) 12822 if !ok { 12823 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 12824 } 12825 sv.Description = ptr.String(jtv) 12826 } 12827 12828 case "FunctionVersion": 12829 if value != nil { 12830 jtv, ok := value.(string) 12831 if !ok { 12832 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 12833 } 12834 sv.FunctionVersion = ptr.String(jtv) 12835 } 12836 12837 case "Name": 12838 if value != nil { 12839 jtv, ok := value.(string) 12840 if !ok { 12841 return fmt.Errorf("expected Alias to be of type string, got %T instead", value) 12842 } 12843 sv.Name = ptr.String(jtv) 12844 } 12845 12846 case "RevisionId": 12847 if value != nil { 12848 jtv, ok := value.(string) 12849 if !ok { 12850 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12851 } 12852 sv.RevisionId = ptr.String(jtv) 12853 } 12854 12855 case "RoutingConfig": 12856 if err := awsRestjson1_deserializeDocumentAliasRoutingConfiguration(&sv.RoutingConfig, value); err != nil { 12857 return err 12858 } 12859 12860 default: 12861 _, _ = key, value 12862 12863 } 12864 } 12865 *v = sv 12866 return nil 12867} 12868 12869func awsRestjson1_deserializeDocumentAliasList(v *[]types.AliasConfiguration, value interface{}) error { 12870 if v == nil { 12871 return fmt.Errorf("unexpected nil of type %T", v) 12872 } 12873 if value == nil { 12874 return nil 12875 } 12876 12877 shape, ok := value.([]interface{}) 12878 if !ok { 12879 return fmt.Errorf("unexpected JSON type %v", value) 12880 } 12881 12882 var cv []types.AliasConfiguration 12883 if *v == nil { 12884 cv = []types.AliasConfiguration{} 12885 } else { 12886 cv = *v 12887 } 12888 12889 for _, value := range shape { 12890 var col types.AliasConfiguration 12891 destAddr := &col 12892 if err := awsRestjson1_deserializeDocumentAliasConfiguration(&destAddr, value); err != nil { 12893 return err 12894 } 12895 col = *destAddr 12896 cv = append(cv, col) 12897 12898 } 12899 *v = cv 12900 return nil 12901} 12902 12903func awsRestjson1_deserializeDocumentAliasRoutingConfiguration(v **types.AliasRoutingConfiguration, value interface{}) error { 12904 if v == nil { 12905 return fmt.Errorf("unexpected nil of type %T", v) 12906 } 12907 if value == nil { 12908 return nil 12909 } 12910 12911 shape, ok := value.(map[string]interface{}) 12912 if !ok { 12913 return fmt.Errorf("unexpected JSON type %v", value) 12914 } 12915 12916 var sv *types.AliasRoutingConfiguration 12917 if *v == nil { 12918 sv = &types.AliasRoutingConfiguration{} 12919 } else { 12920 sv = *v 12921 } 12922 12923 for key, value := range shape { 12924 switch key { 12925 case "AdditionalVersionWeights": 12926 if err := awsRestjson1_deserializeDocumentAdditionalVersionWeights(&sv.AdditionalVersionWeights, value); err != nil { 12927 return err 12928 } 12929 12930 default: 12931 _, _ = key, value 12932 12933 } 12934 } 12935 *v = sv 12936 return nil 12937} 12938 12939func awsRestjson1_deserializeDocumentAllowedPublishers(v **types.AllowedPublishers, value interface{}) error { 12940 if v == nil { 12941 return fmt.Errorf("unexpected nil of type %T", v) 12942 } 12943 if value == nil { 12944 return nil 12945 } 12946 12947 shape, ok := value.(map[string]interface{}) 12948 if !ok { 12949 return fmt.Errorf("unexpected JSON type %v", value) 12950 } 12951 12952 var sv *types.AllowedPublishers 12953 if *v == nil { 12954 sv = &types.AllowedPublishers{} 12955 } else { 12956 sv = *v 12957 } 12958 12959 for key, value := range shape { 12960 switch key { 12961 case "SigningProfileVersionArns": 12962 if err := awsRestjson1_deserializeDocumentSigningProfileVersionArns(&sv.SigningProfileVersionArns, value); err != nil { 12963 return err 12964 } 12965 12966 default: 12967 _, _ = key, value 12968 12969 } 12970 } 12971 *v = sv 12972 return nil 12973} 12974 12975func awsRestjson1_deserializeDocumentCodeSigningConfig(v **types.CodeSigningConfig, value interface{}) error { 12976 if v == nil { 12977 return fmt.Errorf("unexpected nil of type %T", v) 12978 } 12979 if value == nil { 12980 return nil 12981 } 12982 12983 shape, ok := value.(map[string]interface{}) 12984 if !ok { 12985 return fmt.Errorf("unexpected JSON type %v", value) 12986 } 12987 12988 var sv *types.CodeSigningConfig 12989 if *v == nil { 12990 sv = &types.CodeSigningConfig{} 12991 } else { 12992 sv = *v 12993 } 12994 12995 for key, value := range shape { 12996 switch key { 12997 case "AllowedPublishers": 12998 if err := awsRestjson1_deserializeDocumentAllowedPublishers(&sv.AllowedPublishers, value); err != nil { 12999 return err 13000 } 13001 13002 case "CodeSigningConfigArn": 13003 if value != nil { 13004 jtv, ok := value.(string) 13005 if !ok { 13006 return fmt.Errorf("expected CodeSigningConfigArn to be of type string, got %T instead", value) 13007 } 13008 sv.CodeSigningConfigArn = ptr.String(jtv) 13009 } 13010 13011 case "CodeSigningConfigId": 13012 if value != nil { 13013 jtv, ok := value.(string) 13014 if !ok { 13015 return fmt.Errorf("expected CodeSigningConfigId to be of type string, got %T instead", value) 13016 } 13017 sv.CodeSigningConfigId = ptr.String(jtv) 13018 } 13019 13020 case "CodeSigningPolicies": 13021 if err := awsRestjson1_deserializeDocumentCodeSigningPolicies(&sv.CodeSigningPolicies, value); err != nil { 13022 return err 13023 } 13024 13025 case "Description": 13026 if value != nil { 13027 jtv, ok := value.(string) 13028 if !ok { 13029 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 13030 } 13031 sv.Description = ptr.String(jtv) 13032 } 13033 13034 case "LastModified": 13035 if value != nil { 13036 jtv, ok := value.(string) 13037 if !ok { 13038 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 13039 } 13040 sv.LastModified = ptr.String(jtv) 13041 } 13042 13043 default: 13044 _, _ = key, value 13045 13046 } 13047 } 13048 *v = sv 13049 return nil 13050} 13051 13052func awsRestjson1_deserializeDocumentCodeSigningConfigList(v *[]types.CodeSigningConfig, value interface{}) error { 13053 if v == nil { 13054 return fmt.Errorf("unexpected nil of type %T", v) 13055 } 13056 if value == nil { 13057 return nil 13058 } 13059 13060 shape, ok := value.([]interface{}) 13061 if !ok { 13062 return fmt.Errorf("unexpected JSON type %v", value) 13063 } 13064 13065 var cv []types.CodeSigningConfig 13066 if *v == nil { 13067 cv = []types.CodeSigningConfig{} 13068 } else { 13069 cv = *v 13070 } 13071 13072 for _, value := range shape { 13073 var col types.CodeSigningConfig 13074 destAddr := &col 13075 if err := awsRestjson1_deserializeDocumentCodeSigningConfig(&destAddr, value); err != nil { 13076 return err 13077 } 13078 col = *destAddr 13079 cv = append(cv, col) 13080 13081 } 13082 *v = cv 13083 return nil 13084} 13085 13086func awsRestjson1_deserializeDocumentCodeSigningConfigNotFoundException(v **types.CodeSigningConfigNotFoundException, value interface{}) error { 13087 if v == nil { 13088 return fmt.Errorf("unexpected nil of type %T", v) 13089 } 13090 if value == nil { 13091 return nil 13092 } 13093 13094 shape, ok := value.(map[string]interface{}) 13095 if !ok { 13096 return fmt.Errorf("unexpected JSON type %v", value) 13097 } 13098 13099 var sv *types.CodeSigningConfigNotFoundException 13100 if *v == nil { 13101 sv = &types.CodeSigningConfigNotFoundException{} 13102 } else { 13103 sv = *v 13104 } 13105 13106 for key, value := range shape { 13107 switch key { 13108 case "Message": 13109 if value != nil { 13110 jtv, ok := value.(string) 13111 if !ok { 13112 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13113 } 13114 sv.Message = ptr.String(jtv) 13115 } 13116 13117 case "Type": 13118 if value != nil { 13119 jtv, ok := value.(string) 13120 if !ok { 13121 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13122 } 13123 sv.Type = ptr.String(jtv) 13124 } 13125 13126 default: 13127 _, _ = key, value 13128 13129 } 13130 } 13131 *v = sv 13132 return nil 13133} 13134 13135func awsRestjson1_deserializeDocumentCodeSigningPolicies(v **types.CodeSigningPolicies, value interface{}) error { 13136 if v == nil { 13137 return fmt.Errorf("unexpected nil of type %T", v) 13138 } 13139 if value == nil { 13140 return nil 13141 } 13142 13143 shape, ok := value.(map[string]interface{}) 13144 if !ok { 13145 return fmt.Errorf("unexpected JSON type %v", value) 13146 } 13147 13148 var sv *types.CodeSigningPolicies 13149 if *v == nil { 13150 sv = &types.CodeSigningPolicies{} 13151 } else { 13152 sv = *v 13153 } 13154 13155 for key, value := range shape { 13156 switch key { 13157 case "UntrustedArtifactOnDeployment": 13158 if value != nil { 13159 jtv, ok := value.(string) 13160 if !ok { 13161 return fmt.Errorf("expected CodeSigningPolicy to be of type string, got %T instead", value) 13162 } 13163 sv.UntrustedArtifactOnDeployment = types.CodeSigningPolicy(jtv) 13164 } 13165 13166 default: 13167 _, _ = key, value 13168 13169 } 13170 } 13171 *v = sv 13172 return nil 13173} 13174 13175func awsRestjson1_deserializeDocumentCodeStorageExceededException(v **types.CodeStorageExceededException, value interface{}) error { 13176 if v == nil { 13177 return fmt.Errorf("unexpected nil of type %T", v) 13178 } 13179 if value == nil { 13180 return nil 13181 } 13182 13183 shape, ok := value.(map[string]interface{}) 13184 if !ok { 13185 return fmt.Errorf("unexpected JSON type %v", value) 13186 } 13187 13188 var sv *types.CodeStorageExceededException 13189 if *v == nil { 13190 sv = &types.CodeStorageExceededException{} 13191 } else { 13192 sv = *v 13193 } 13194 13195 for key, value := range shape { 13196 switch key { 13197 case "message": 13198 if value != nil { 13199 jtv, ok := value.(string) 13200 if !ok { 13201 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13202 } 13203 sv.Message = ptr.String(jtv) 13204 } 13205 13206 case "Type": 13207 if value != nil { 13208 jtv, ok := value.(string) 13209 if !ok { 13210 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13211 } 13212 sv.Type = ptr.String(jtv) 13213 } 13214 13215 default: 13216 _, _ = key, value 13217 13218 } 13219 } 13220 *v = sv 13221 return nil 13222} 13223 13224func awsRestjson1_deserializeDocumentCodeVerificationFailedException(v **types.CodeVerificationFailedException, value interface{}) error { 13225 if v == nil { 13226 return fmt.Errorf("unexpected nil of type %T", v) 13227 } 13228 if value == nil { 13229 return nil 13230 } 13231 13232 shape, ok := value.(map[string]interface{}) 13233 if !ok { 13234 return fmt.Errorf("unexpected JSON type %v", value) 13235 } 13236 13237 var sv *types.CodeVerificationFailedException 13238 if *v == nil { 13239 sv = &types.CodeVerificationFailedException{} 13240 } else { 13241 sv = *v 13242 } 13243 13244 for key, value := range shape { 13245 switch key { 13246 case "Message": 13247 if value != nil { 13248 jtv, ok := value.(string) 13249 if !ok { 13250 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13251 } 13252 sv.Message = ptr.String(jtv) 13253 } 13254 13255 case "Type": 13256 if value != nil { 13257 jtv, ok := value.(string) 13258 if !ok { 13259 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13260 } 13261 sv.Type = ptr.String(jtv) 13262 } 13263 13264 default: 13265 _, _ = key, value 13266 13267 } 13268 } 13269 *v = sv 13270 return nil 13271} 13272 13273func awsRestjson1_deserializeDocumentCompatibleRuntimes(v *[]types.Runtime, value interface{}) error { 13274 if v == nil { 13275 return fmt.Errorf("unexpected nil of type %T", v) 13276 } 13277 if value == nil { 13278 return nil 13279 } 13280 13281 shape, ok := value.([]interface{}) 13282 if !ok { 13283 return fmt.Errorf("unexpected JSON type %v", value) 13284 } 13285 13286 var cv []types.Runtime 13287 if *v == nil { 13288 cv = []types.Runtime{} 13289 } else { 13290 cv = *v 13291 } 13292 13293 for _, value := range shape { 13294 var col types.Runtime 13295 if value != nil { 13296 jtv, ok := value.(string) 13297 if !ok { 13298 return fmt.Errorf("expected Runtime to be of type string, got %T instead", value) 13299 } 13300 col = types.Runtime(jtv) 13301 } 13302 cv = append(cv, col) 13303 13304 } 13305 *v = cv 13306 return nil 13307} 13308 13309func awsRestjson1_deserializeDocumentConcurrency(v **types.Concurrency, value interface{}) error { 13310 if v == nil { 13311 return fmt.Errorf("unexpected nil of type %T", v) 13312 } 13313 if value == nil { 13314 return nil 13315 } 13316 13317 shape, ok := value.(map[string]interface{}) 13318 if !ok { 13319 return fmt.Errorf("unexpected JSON type %v", value) 13320 } 13321 13322 var sv *types.Concurrency 13323 if *v == nil { 13324 sv = &types.Concurrency{} 13325 } else { 13326 sv = *v 13327 } 13328 13329 for key, value := range shape { 13330 switch key { 13331 case "ReservedConcurrentExecutions": 13332 if value != nil { 13333 jtv, ok := value.(json.Number) 13334 if !ok { 13335 return fmt.Errorf("expected ReservedConcurrentExecutions to be json.Number, got %T instead", value) 13336 } 13337 i64, err := jtv.Int64() 13338 if err != nil { 13339 return err 13340 } 13341 sv.ReservedConcurrentExecutions = ptr.Int32(int32(i64)) 13342 } 13343 13344 default: 13345 _, _ = key, value 13346 13347 } 13348 } 13349 *v = sv 13350 return nil 13351} 13352 13353func awsRestjson1_deserializeDocumentDeadLetterConfig(v **types.DeadLetterConfig, value interface{}) error { 13354 if v == nil { 13355 return fmt.Errorf("unexpected nil of type %T", v) 13356 } 13357 if value == nil { 13358 return nil 13359 } 13360 13361 shape, ok := value.(map[string]interface{}) 13362 if !ok { 13363 return fmt.Errorf("unexpected JSON type %v", value) 13364 } 13365 13366 var sv *types.DeadLetterConfig 13367 if *v == nil { 13368 sv = &types.DeadLetterConfig{} 13369 } else { 13370 sv = *v 13371 } 13372 13373 for key, value := range shape { 13374 switch key { 13375 case "TargetArn": 13376 if value != nil { 13377 jtv, ok := value.(string) 13378 if !ok { 13379 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 13380 } 13381 sv.TargetArn = ptr.String(jtv) 13382 } 13383 13384 default: 13385 _, _ = key, value 13386 13387 } 13388 } 13389 *v = sv 13390 return nil 13391} 13392 13393func awsRestjson1_deserializeDocumentDestinationConfig(v **types.DestinationConfig, value interface{}) error { 13394 if v == nil { 13395 return fmt.Errorf("unexpected nil of type %T", v) 13396 } 13397 if value == nil { 13398 return nil 13399 } 13400 13401 shape, ok := value.(map[string]interface{}) 13402 if !ok { 13403 return fmt.Errorf("unexpected JSON type %v", value) 13404 } 13405 13406 var sv *types.DestinationConfig 13407 if *v == nil { 13408 sv = &types.DestinationConfig{} 13409 } else { 13410 sv = *v 13411 } 13412 13413 for key, value := range shape { 13414 switch key { 13415 case "OnFailure": 13416 if err := awsRestjson1_deserializeDocumentOnFailure(&sv.OnFailure, value); err != nil { 13417 return err 13418 } 13419 13420 case "OnSuccess": 13421 if err := awsRestjson1_deserializeDocumentOnSuccess(&sv.OnSuccess, value); err != nil { 13422 return err 13423 } 13424 13425 default: 13426 _, _ = key, value 13427 13428 } 13429 } 13430 *v = sv 13431 return nil 13432} 13433 13434func awsRestjson1_deserializeDocumentEC2AccessDeniedException(v **types.EC2AccessDeniedException, value interface{}) error { 13435 if v == nil { 13436 return fmt.Errorf("unexpected nil of type %T", v) 13437 } 13438 if value == nil { 13439 return nil 13440 } 13441 13442 shape, ok := value.(map[string]interface{}) 13443 if !ok { 13444 return fmt.Errorf("unexpected JSON type %v", value) 13445 } 13446 13447 var sv *types.EC2AccessDeniedException 13448 if *v == nil { 13449 sv = &types.EC2AccessDeniedException{} 13450 } else { 13451 sv = *v 13452 } 13453 13454 for key, value := range shape { 13455 switch key { 13456 case "Message": 13457 if value != nil { 13458 jtv, ok := value.(string) 13459 if !ok { 13460 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13461 } 13462 sv.Message = ptr.String(jtv) 13463 } 13464 13465 case "Type": 13466 if value != nil { 13467 jtv, ok := value.(string) 13468 if !ok { 13469 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13470 } 13471 sv.Type = ptr.String(jtv) 13472 } 13473 13474 default: 13475 _, _ = key, value 13476 13477 } 13478 } 13479 *v = sv 13480 return nil 13481} 13482 13483func awsRestjson1_deserializeDocumentEC2ThrottledException(v **types.EC2ThrottledException, value interface{}) error { 13484 if v == nil { 13485 return fmt.Errorf("unexpected nil of type %T", v) 13486 } 13487 if value == nil { 13488 return nil 13489 } 13490 13491 shape, ok := value.(map[string]interface{}) 13492 if !ok { 13493 return fmt.Errorf("unexpected JSON type %v", value) 13494 } 13495 13496 var sv *types.EC2ThrottledException 13497 if *v == nil { 13498 sv = &types.EC2ThrottledException{} 13499 } else { 13500 sv = *v 13501 } 13502 13503 for key, value := range shape { 13504 switch key { 13505 case "Message": 13506 if value != nil { 13507 jtv, ok := value.(string) 13508 if !ok { 13509 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13510 } 13511 sv.Message = ptr.String(jtv) 13512 } 13513 13514 case "Type": 13515 if value != nil { 13516 jtv, ok := value.(string) 13517 if !ok { 13518 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13519 } 13520 sv.Type = ptr.String(jtv) 13521 } 13522 13523 default: 13524 _, _ = key, value 13525 13526 } 13527 } 13528 *v = sv 13529 return nil 13530} 13531 13532func awsRestjson1_deserializeDocumentEC2UnexpectedException(v **types.EC2UnexpectedException, value interface{}) error { 13533 if v == nil { 13534 return fmt.Errorf("unexpected nil of type %T", v) 13535 } 13536 if value == nil { 13537 return nil 13538 } 13539 13540 shape, ok := value.(map[string]interface{}) 13541 if !ok { 13542 return fmt.Errorf("unexpected JSON type %v", value) 13543 } 13544 13545 var sv *types.EC2UnexpectedException 13546 if *v == nil { 13547 sv = &types.EC2UnexpectedException{} 13548 } else { 13549 sv = *v 13550 } 13551 13552 for key, value := range shape { 13553 switch key { 13554 case "EC2ErrorCode": 13555 if value != nil { 13556 jtv, ok := value.(string) 13557 if !ok { 13558 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13559 } 13560 sv.EC2ErrorCode = ptr.String(jtv) 13561 } 13562 13563 case "Message": 13564 if value != nil { 13565 jtv, ok := value.(string) 13566 if !ok { 13567 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13568 } 13569 sv.Message = ptr.String(jtv) 13570 } 13571 13572 case "Type": 13573 if value != nil { 13574 jtv, ok := value.(string) 13575 if !ok { 13576 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13577 } 13578 sv.Type = ptr.String(jtv) 13579 } 13580 13581 default: 13582 _, _ = key, value 13583 13584 } 13585 } 13586 *v = sv 13587 return nil 13588} 13589 13590func awsRestjson1_deserializeDocumentEFSIOException(v **types.EFSIOException, value interface{}) error { 13591 if v == nil { 13592 return fmt.Errorf("unexpected nil of type %T", v) 13593 } 13594 if value == nil { 13595 return nil 13596 } 13597 13598 shape, ok := value.(map[string]interface{}) 13599 if !ok { 13600 return fmt.Errorf("unexpected JSON type %v", value) 13601 } 13602 13603 var sv *types.EFSIOException 13604 if *v == nil { 13605 sv = &types.EFSIOException{} 13606 } else { 13607 sv = *v 13608 } 13609 13610 for key, value := range shape { 13611 switch key { 13612 case "Message": 13613 if value != nil { 13614 jtv, ok := value.(string) 13615 if !ok { 13616 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13617 } 13618 sv.Message = ptr.String(jtv) 13619 } 13620 13621 case "Type": 13622 if value != nil { 13623 jtv, ok := value.(string) 13624 if !ok { 13625 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13626 } 13627 sv.Type = ptr.String(jtv) 13628 } 13629 13630 default: 13631 _, _ = key, value 13632 13633 } 13634 } 13635 *v = sv 13636 return nil 13637} 13638 13639func awsRestjson1_deserializeDocumentEFSMountConnectivityException(v **types.EFSMountConnectivityException, value interface{}) error { 13640 if v == nil { 13641 return fmt.Errorf("unexpected nil of type %T", v) 13642 } 13643 if value == nil { 13644 return nil 13645 } 13646 13647 shape, ok := value.(map[string]interface{}) 13648 if !ok { 13649 return fmt.Errorf("unexpected JSON type %v", value) 13650 } 13651 13652 var sv *types.EFSMountConnectivityException 13653 if *v == nil { 13654 sv = &types.EFSMountConnectivityException{} 13655 } else { 13656 sv = *v 13657 } 13658 13659 for key, value := range shape { 13660 switch key { 13661 case "Message": 13662 if value != nil { 13663 jtv, ok := value.(string) 13664 if !ok { 13665 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13666 } 13667 sv.Message = ptr.String(jtv) 13668 } 13669 13670 case "Type": 13671 if value != nil { 13672 jtv, ok := value.(string) 13673 if !ok { 13674 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13675 } 13676 sv.Type = ptr.String(jtv) 13677 } 13678 13679 default: 13680 _, _ = key, value 13681 13682 } 13683 } 13684 *v = sv 13685 return nil 13686} 13687 13688func awsRestjson1_deserializeDocumentEFSMountFailureException(v **types.EFSMountFailureException, value interface{}) error { 13689 if v == nil { 13690 return fmt.Errorf("unexpected nil of type %T", v) 13691 } 13692 if value == nil { 13693 return nil 13694 } 13695 13696 shape, ok := value.(map[string]interface{}) 13697 if !ok { 13698 return fmt.Errorf("unexpected JSON type %v", value) 13699 } 13700 13701 var sv *types.EFSMountFailureException 13702 if *v == nil { 13703 sv = &types.EFSMountFailureException{} 13704 } else { 13705 sv = *v 13706 } 13707 13708 for key, value := range shape { 13709 switch key { 13710 case "Message": 13711 if value != nil { 13712 jtv, ok := value.(string) 13713 if !ok { 13714 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13715 } 13716 sv.Message = ptr.String(jtv) 13717 } 13718 13719 case "Type": 13720 if value != nil { 13721 jtv, ok := value.(string) 13722 if !ok { 13723 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13724 } 13725 sv.Type = ptr.String(jtv) 13726 } 13727 13728 default: 13729 _, _ = key, value 13730 13731 } 13732 } 13733 *v = sv 13734 return nil 13735} 13736 13737func awsRestjson1_deserializeDocumentEFSMountTimeoutException(v **types.EFSMountTimeoutException, value interface{}) error { 13738 if v == nil { 13739 return fmt.Errorf("unexpected nil of type %T", v) 13740 } 13741 if value == nil { 13742 return nil 13743 } 13744 13745 shape, ok := value.(map[string]interface{}) 13746 if !ok { 13747 return fmt.Errorf("unexpected JSON type %v", value) 13748 } 13749 13750 var sv *types.EFSMountTimeoutException 13751 if *v == nil { 13752 sv = &types.EFSMountTimeoutException{} 13753 } else { 13754 sv = *v 13755 } 13756 13757 for key, value := range shape { 13758 switch key { 13759 case "Message": 13760 if value != nil { 13761 jtv, ok := value.(string) 13762 if !ok { 13763 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13764 } 13765 sv.Message = ptr.String(jtv) 13766 } 13767 13768 case "Type": 13769 if value != nil { 13770 jtv, ok := value.(string) 13771 if !ok { 13772 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13773 } 13774 sv.Type = ptr.String(jtv) 13775 } 13776 13777 default: 13778 _, _ = key, value 13779 13780 } 13781 } 13782 *v = sv 13783 return nil 13784} 13785 13786func awsRestjson1_deserializeDocumentEndpointLists(v *[]string, value interface{}) error { 13787 if v == nil { 13788 return fmt.Errorf("unexpected nil of type %T", v) 13789 } 13790 if value == nil { 13791 return nil 13792 } 13793 13794 shape, ok := value.([]interface{}) 13795 if !ok { 13796 return fmt.Errorf("unexpected JSON type %v", value) 13797 } 13798 13799 var cv []string 13800 if *v == nil { 13801 cv = []string{} 13802 } else { 13803 cv = *v 13804 } 13805 13806 for _, value := range shape { 13807 var col string 13808 if value != nil { 13809 jtv, ok := value.(string) 13810 if !ok { 13811 return fmt.Errorf("expected Endpoint to be of type string, got %T instead", value) 13812 } 13813 col = jtv 13814 } 13815 cv = append(cv, col) 13816 13817 } 13818 *v = cv 13819 return nil 13820} 13821 13822func awsRestjson1_deserializeDocumentEndpoints(v *map[string][]string, value interface{}) error { 13823 if v == nil { 13824 return fmt.Errorf("unexpected nil of type %T", v) 13825 } 13826 if value == nil { 13827 return nil 13828 } 13829 13830 shape, ok := value.(map[string]interface{}) 13831 if !ok { 13832 return fmt.Errorf("unexpected JSON type %v", value) 13833 } 13834 13835 var mv map[string][]string 13836 if *v == nil { 13837 mv = map[string][]string{} 13838 } else { 13839 mv = *v 13840 } 13841 13842 for key, value := range shape { 13843 var parsedVal []string 13844 mapVar := parsedVal 13845 if err := awsRestjson1_deserializeDocumentEndpointLists(&mapVar, value); err != nil { 13846 return err 13847 } 13848 parsedVal = mapVar 13849 mv[key] = parsedVal 13850 13851 } 13852 *v = mv 13853 return nil 13854} 13855 13856func awsRestjson1_deserializeDocumentENILimitReachedException(v **types.ENILimitReachedException, value interface{}) error { 13857 if v == nil { 13858 return fmt.Errorf("unexpected nil of type %T", v) 13859 } 13860 if value == nil { 13861 return nil 13862 } 13863 13864 shape, ok := value.(map[string]interface{}) 13865 if !ok { 13866 return fmt.Errorf("unexpected JSON type %v", value) 13867 } 13868 13869 var sv *types.ENILimitReachedException 13870 if *v == nil { 13871 sv = &types.ENILimitReachedException{} 13872 } else { 13873 sv = *v 13874 } 13875 13876 for key, value := range shape { 13877 switch key { 13878 case "Message": 13879 if value != nil { 13880 jtv, ok := value.(string) 13881 if !ok { 13882 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13883 } 13884 sv.Message = ptr.String(jtv) 13885 } 13886 13887 case "Type": 13888 if value != nil { 13889 jtv, ok := value.(string) 13890 if !ok { 13891 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13892 } 13893 sv.Type = ptr.String(jtv) 13894 } 13895 13896 default: 13897 _, _ = key, value 13898 13899 } 13900 } 13901 *v = sv 13902 return nil 13903} 13904 13905func awsRestjson1_deserializeDocumentEnvironmentError(v **types.EnvironmentError, value interface{}) error { 13906 if v == nil { 13907 return fmt.Errorf("unexpected nil of type %T", v) 13908 } 13909 if value == nil { 13910 return nil 13911 } 13912 13913 shape, ok := value.(map[string]interface{}) 13914 if !ok { 13915 return fmt.Errorf("unexpected JSON type %v", value) 13916 } 13917 13918 var sv *types.EnvironmentError 13919 if *v == nil { 13920 sv = &types.EnvironmentError{} 13921 } else { 13922 sv = *v 13923 } 13924 13925 for key, value := range shape { 13926 switch key { 13927 case "ErrorCode": 13928 if value != nil { 13929 jtv, ok := value.(string) 13930 if !ok { 13931 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13932 } 13933 sv.ErrorCode = ptr.String(jtv) 13934 } 13935 13936 case "Message": 13937 if value != nil { 13938 jtv, ok := value.(string) 13939 if !ok { 13940 return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value) 13941 } 13942 sv.Message = ptr.String(jtv) 13943 } 13944 13945 default: 13946 _, _ = key, value 13947 13948 } 13949 } 13950 *v = sv 13951 return nil 13952} 13953 13954func awsRestjson1_deserializeDocumentEnvironmentResponse(v **types.EnvironmentResponse, value interface{}) error { 13955 if v == nil { 13956 return fmt.Errorf("unexpected nil of type %T", v) 13957 } 13958 if value == nil { 13959 return nil 13960 } 13961 13962 shape, ok := value.(map[string]interface{}) 13963 if !ok { 13964 return fmt.Errorf("unexpected JSON type %v", value) 13965 } 13966 13967 var sv *types.EnvironmentResponse 13968 if *v == nil { 13969 sv = &types.EnvironmentResponse{} 13970 } else { 13971 sv = *v 13972 } 13973 13974 for key, value := range shape { 13975 switch key { 13976 case "Error": 13977 if err := awsRestjson1_deserializeDocumentEnvironmentError(&sv.Error, value); err != nil { 13978 return err 13979 } 13980 13981 case "Variables": 13982 if err := awsRestjson1_deserializeDocumentEnvironmentVariables(&sv.Variables, value); err != nil { 13983 return err 13984 } 13985 13986 default: 13987 _, _ = key, value 13988 13989 } 13990 } 13991 *v = sv 13992 return nil 13993} 13994 13995func awsRestjson1_deserializeDocumentEnvironmentVariables(v *map[string]string, value interface{}) error { 13996 if v == nil { 13997 return fmt.Errorf("unexpected nil of type %T", v) 13998 } 13999 if value == nil { 14000 return nil 14001 } 14002 14003 shape, ok := value.(map[string]interface{}) 14004 if !ok { 14005 return fmt.Errorf("unexpected JSON type %v", value) 14006 } 14007 14008 var mv map[string]string 14009 if *v == nil { 14010 mv = map[string]string{} 14011 } else { 14012 mv = *v 14013 } 14014 14015 for key, value := range shape { 14016 var parsedVal string 14017 if value != nil { 14018 jtv, ok := value.(string) 14019 if !ok { 14020 return fmt.Errorf("expected EnvironmentVariableValue to be of type string, got %T instead", value) 14021 } 14022 parsedVal = jtv 14023 } 14024 mv[key] = parsedVal 14025 14026 } 14027 *v = mv 14028 return nil 14029} 14030 14031func awsRestjson1_deserializeDocumentEventSourceMappingConfiguration(v **types.EventSourceMappingConfiguration, value interface{}) error { 14032 if v == nil { 14033 return fmt.Errorf("unexpected nil of type %T", v) 14034 } 14035 if value == nil { 14036 return nil 14037 } 14038 14039 shape, ok := value.(map[string]interface{}) 14040 if !ok { 14041 return fmt.Errorf("unexpected JSON type %v", value) 14042 } 14043 14044 var sv *types.EventSourceMappingConfiguration 14045 if *v == nil { 14046 sv = &types.EventSourceMappingConfiguration{} 14047 } else { 14048 sv = *v 14049 } 14050 14051 for key, value := range shape { 14052 switch key { 14053 case "BatchSize": 14054 if value != nil { 14055 jtv, ok := value.(json.Number) 14056 if !ok { 14057 return fmt.Errorf("expected BatchSize to be json.Number, got %T instead", value) 14058 } 14059 i64, err := jtv.Int64() 14060 if err != nil { 14061 return err 14062 } 14063 sv.BatchSize = ptr.Int32(int32(i64)) 14064 } 14065 14066 case "BisectBatchOnFunctionError": 14067 if value != nil { 14068 jtv, ok := value.(bool) 14069 if !ok { 14070 return fmt.Errorf("expected BisectBatchOnFunctionError to be of type *bool, got %T instead", value) 14071 } 14072 sv.BisectBatchOnFunctionError = ptr.Bool(jtv) 14073 } 14074 14075 case "DestinationConfig": 14076 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 14077 return err 14078 } 14079 14080 case "EventSourceArn": 14081 if value != nil { 14082 jtv, ok := value.(string) 14083 if !ok { 14084 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 14085 } 14086 sv.EventSourceArn = ptr.String(jtv) 14087 } 14088 14089 case "FunctionArn": 14090 if value != nil { 14091 jtv, ok := value.(string) 14092 if !ok { 14093 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 14094 } 14095 sv.FunctionArn = ptr.String(jtv) 14096 } 14097 14098 case "FunctionResponseTypes": 14099 if err := awsRestjson1_deserializeDocumentFunctionResponseTypeList(&sv.FunctionResponseTypes, value); err != nil { 14100 return err 14101 } 14102 14103 case "LastModified": 14104 if value != nil { 14105 jtv, ok := value.(json.Number) 14106 if !ok { 14107 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 14108 } 14109 f64, err := jtv.Float64() 14110 if err != nil { 14111 return err 14112 } 14113 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14114 } 14115 14116 case "LastProcessingResult": 14117 if value != nil { 14118 jtv, ok := value.(string) 14119 if !ok { 14120 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14121 } 14122 sv.LastProcessingResult = ptr.String(jtv) 14123 } 14124 14125 case "MaximumBatchingWindowInSeconds": 14126 if value != nil { 14127 jtv, ok := value.(json.Number) 14128 if !ok { 14129 return fmt.Errorf("expected MaximumBatchingWindowInSeconds to be json.Number, got %T instead", value) 14130 } 14131 i64, err := jtv.Int64() 14132 if err != nil { 14133 return err 14134 } 14135 sv.MaximumBatchingWindowInSeconds = ptr.Int32(int32(i64)) 14136 } 14137 14138 case "MaximumRecordAgeInSeconds": 14139 if value != nil { 14140 jtv, ok := value.(json.Number) 14141 if !ok { 14142 return fmt.Errorf("expected MaximumRecordAgeInSeconds to be json.Number, got %T instead", value) 14143 } 14144 i64, err := jtv.Int64() 14145 if err != nil { 14146 return err 14147 } 14148 sv.MaximumRecordAgeInSeconds = ptr.Int32(int32(i64)) 14149 } 14150 14151 case "MaximumRetryAttempts": 14152 if value != nil { 14153 jtv, ok := value.(json.Number) 14154 if !ok { 14155 return fmt.Errorf("expected MaximumRetryAttemptsEventSourceMapping to be json.Number, got %T instead", value) 14156 } 14157 i64, err := jtv.Int64() 14158 if err != nil { 14159 return err 14160 } 14161 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 14162 } 14163 14164 case "ParallelizationFactor": 14165 if value != nil { 14166 jtv, ok := value.(json.Number) 14167 if !ok { 14168 return fmt.Errorf("expected ParallelizationFactor to be json.Number, got %T instead", value) 14169 } 14170 i64, err := jtv.Int64() 14171 if err != nil { 14172 return err 14173 } 14174 sv.ParallelizationFactor = ptr.Int32(int32(i64)) 14175 } 14176 14177 case "Queues": 14178 if err := awsRestjson1_deserializeDocumentQueues(&sv.Queues, value); err != nil { 14179 return err 14180 } 14181 14182 case "SelfManagedEventSource": 14183 if err := awsRestjson1_deserializeDocumentSelfManagedEventSource(&sv.SelfManagedEventSource, value); err != nil { 14184 return err 14185 } 14186 14187 case "SourceAccessConfigurations": 14188 if err := awsRestjson1_deserializeDocumentSourceAccessConfigurations(&sv.SourceAccessConfigurations, value); err != nil { 14189 return err 14190 } 14191 14192 case "StartingPosition": 14193 if value != nil { 14194 jtv, ok := value.(string) 14195 if !ok { 14196 return fmt.Errorf("expected EventSourcePosition to be of type string, got %T instead", value) 14197 } 14198 sv.StartingPosition = types.EventSourcePosition(jtv) 14199 } 14200 14201 case "StartingPositionTimestamp": 14202 if value != nil { 14203 jtv, ok := value.(json.Number) 14204 if !ok { 14205 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 14206 } 14207 f64, err := jtv.Float64() 14208 if err != nil { 14209 return err 14210 } 14211 sv.StartingPositionTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14212 } 14213 14214 case "State": 14215 if value != nil { 14216 jtv, ok := value.(string) 14217 if !ok { 14218 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14219 } 14220 sv.State = ptr.String(jtv) 14221 } 14222 14223 case "StateTransitionReason": 14224 if value != nil { 14225 jtv, ok := value.(string) 14226 if !ok { 14227 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14228 } 14229 sv.StateTransitionReason = ptr.String(jtv) 14230 } 14231 14232 case "Topics": 14233 if err := awsRestjson1_deserializeDocumentTopics(&sv.Topics, value); err != nil { 14234 return err 14235 } 14236 14237 case "TumblingWindowInSeconds": 14238 if value != nil { 14239 jtv, ok := value.(json.Number) 14240 if !ok { 14241 return fmt.Errorf("expected TumblingWindowInSeconds to be json.Number, got %T instead", value) 14242 } 14243 i64, err := jtv.Int64() 14244 if err != nil { 14245 return err 14246 } 14247 sv.TumblingWindowInSeconds = ptr.Int32(int32(i64)) 14248 } 14249 14250 case "UUID": 14251 if value != nil { 14252 jtv, ok := value.(string) 14253 if !ok { 14254 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14255 } 14256 sv.UUID = ptr.String(jtv) 14257 } 14258 14259 default: 14260 _, _ = key, value 14261 14262 } 14263 } 14264 *v = sv 14265 return nil 14266} 14267 14268func awsRestjson1_deserializeDocumentEventSourceMappingsList(v *[]types.EventSourceMappingConfiguration, value interface{}) error { 14269 if v == nil { 14270 return fmt.Errorf("unexpected nil of type %T", v) 14271 } 14272 if value == nil { 14273 return nil 14274 } 14275 14276 shape, ok := value.([]interface{}) 14277 if !ok { 14278 return fmt.Errorf("unexpected JSON type %v", value) 14279 } 14280 14281 var cv []types.EventSourceMappingConfiguration 14282 if *v == nil { 14283 cv = []types.EventSourceMappingConfiguration{} 14284 } else { 14285 cv = *v 14286 } 14287 14288 for _, value := range shape { 14289 var col types.EventSourceMappingConfiguration 14290 destAddr := &col 14291 if err := awsRestjson1_deserializeDocumentEventSourceMappingConfiguration(&destAddr, value); err != nil { 14292 return err 14293 } 14294 col = *destAddr 14295 cv = append(cv, col) 14296 14297 } 14298 *v = cv 14299 return nil 14300} 14301 14302func awsRestjson1_deserializeDocumentFileSystemConfig(v **types.FileSystemConfig, value interface{}) error { 14303 if v == nil { 14304 return fmt.Errorf("unexpected nil of type %T", v) 14305 } 14306 if value == nil { 14307 return nil 14308 } 14309 14310 shape, ok := value.(map[string]interface{}) 14311 if !ok { 14312 return fmt.Errorf("unexpected JSON type %v", value) 14313 } 14314 14315 var sv *types.FileSystemConfig 14316 if *v == nil { 14317 sv = &types.FileSystemConfig{} 14318 } else { 14319 sv = *v 14320 } 14321 14322 for key, value := range shape { 14323 switch key { 14324 case "Arn": 14325 if value != nil { 14326 jtv, ok := value.(string) 14327 if !ok { 14328 return fmt.Errorf("expected FileSystemArn to be of type string, got %T instead", value) 14329 } 14330 sv.Arn = ptr.String(jtv) 14331 } 14332 14333 case "LocalMountPath": 14334 if value != nil { 14335 jtv, ok := value.(string) 14336 if !ok { 14337 return fmt.Errorf("expected LocalMountPath to be of type string, got %T instead", value) 14338 } 14339 sv.LocalMountPath = ptr.String(jtv) 14340 } 14341 14342 default: 14343 _, _ = key, value 14344 14345 } 14346 } 14347 *v = sv 14348 return nil 14349} 14350 14351func awsRestjson1_deserializeDocumentFileSystemConfigList(v *[]types.FileSystemConfig, value interface{}) error { 14352 if v == nil { 14353 return fmt.Errorf("unexpected nil of type %T", v) 14354 } 14355 if value == nil { 14356 return nil 14357 } 14358 14359 shape, ok := value.([]interface{}) 14360 if !ok { 14361 return fmt.Errorf("unexpected JSON type %v", value) 14362 } 14363 14364 var cv []types.FileSystemConfig 14365 if *v == nil { 14366 cv = []types.FileSystemConfig{} 14367 } else { 14368 cv = *v 14369 } 14370 14371 for _, value := range shape { 14372 var col types.FileSystemConfig 14373 destAddr := &col 14374 if err := awsRestjson1_deserializeDocumentFileSystemConfig(&destAddr, value); err != nil { 14375 return err 14376 } 14377 col = *destAddr 14378 cv = append(cv, col) 14379 14380 } 14381 *v = cv 14382 return nil 14383} 14384 14385func awsRestjson1_deserializeDocumentFunctionArnList(v *[]string, value interface{}) error { 14386 if v == nil { 14387 return fmt.Errorf("unexpected nil of type %T", v) 14388 } 14389 if value == nil { 14390 return nil 14391 } 14392 14393 shape, ok := value.([]interface{}) 14394 if !ok { 14395 return fmt.Errorf("unexpected JSON type %v", value) 14396 } 14397 14398 var cv []string 14399 if *v == nil { 14400 cv = []string{} 14401 } else { 14402 cv = *v 14403 } 14404 14405 for _, value := range shape { 14406 var col string 14407 if value != nil { 14408 jtv, ok := value.(string) 14409 if !ok { 14410 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 14411 } 14412 col = jtv 14413 } 14414 cv = append(cv, col) 14415 14416 } 14417 *v = cv 14418 return nil 14419} 14420 14421func awsRestjson1_deserializeDocumentFunctionCodeLocation(v **types.FunctionCodeLocation, value interface{}) error { 14422 if v == nil { 14423 return fmt.Errorf("unexpected nil of type %T", v) 14424 } 14425 if value == nil { 14426 return nil 14427 } 14428 14429 shape, ok := value.(map[string]interface{}) 14430 if !ok { 14431 return fmt.Errorf("unexpected JSON type %v", value) 14432 } 14433 14434 var sv *types.FunctionCodeLocation 14435 if *v == nil { 14436 sv = &types.FunctionCodeLocation{} 14437 } else { 14438 sv = *v 14439 } 14440 14441 for key, value := range shape { 14442 switch key { 14443 case "ImageUri": 14444 if value != nil { 14445 jtv, ok := value.(string) 14446 if !ok { 14447 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14448 } 14449 sv.ImageUri = ptr.String(jtv) 14450 } 14451 14452 case "Location": 14453 if value != nil { 14454 jtv, ok := value.(string) 14455 if !ok { 14456 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14457 } 14458 sv.Location = ptr.String(jtv) 14459 } 14460 14461 case "RepositoryType": 14462 if value != nil { 14463 jtv, ok := value.(string) 14464 if !ok { 14465 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14466 } 14467 sv.RepositoryType = ptr.String(jtv) 14468 } 14469 14470 case "ResolvedImageUri": 14471 if value != nil { 14472 jtv, ok := value.(string) 14473 if !ok { 14474 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14475 } 14476 sv.ResolvedImageUri = ptr.String(jtv) 14477 } 14478 14479 default: 14480 _, _ = key, value 14481 14482 } 14483 } 14484 *v = sv 14485 return nil 14486} 14487 14488func awsRestjson1_deserializeDocumentFunctionConfiguration(v **types.FunctionConfiguration, value interface{}) error { 14489 if v == nil { 14490 return fmt.Errorf("unexpected nil of type %T", v) 14491 } 14492 if value == nil { 14493 return nil 14494 } 14495 14496 shape, ok := value.(map[string]interface{}) 14497 if !ok { 14498 return fmt.Errorf("unexpected JSON type %v", value) 14499 } 14500 14501 var sv *types.FunctionConfiguration 14502 if *v == nil { 14503 sv = &types.FunctionConfiguration{} 14504 } else { 14505 sv = *v 14506 } 14507 14508 for key, value := range shape { 14509 switch key { 14510 case "CodeSha256": 14511 if value != nil { 14512 jtv, ok := value.(string) 14513 if !ok { 14514 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14515 } 14516 sv.CodeSha256 = ptr.String(jtv) 14517 } 14518 14519 case "CodeSize": 14520 if value != nil { 14521 jtv, ok := value.(json.Number) 14522 if !ok { 14523 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 14524 } 14525 i64, err := jtv.Int64() 14526 if err != nil { 14527 return err 14528 } 14529 sv.CodeSize = i64 14530 } 14531 14532 case "DeadLetterConfig": 14533 if err := awsRestjson1_deserializeDocumentDeadLetterConfig(&sv.DeadLetterConfig, value); err != nil { 14534 return err 14535 } 14536 14537 case "Description": 14538 if value != nil { 14539 jtv, ok := value.(string) 14540 if !ok { 14541 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 14542 } 14543 sv.Description = ptr.String(jtv) 14544 } 14545 14546 case "Environment": 14547 if err := awsRestjson1_deserializeDocumentEnvironmentResponse(&sv.Environment, value); err != nil { 14548 return err 14549 } 14550 14551 case "FileSystemConfigs": 14552 if err := awsRestjson1_deserializeDocumentFileSystemConfigList(&sv.FileSystemConfigs, value); err != nil { 14553 return err 14554 } 14555 14556 case "FunctionArn": 14557 if value != nil { 14558 jtv, ok := value.(string) 14559 if !ok { 14560 return fmt.Errorf("expected NameSpacedFunctionArn to be of type string, got %T instead", value) 14561 } 14562 sv.FunctionArn = ptr.String(jtv) 14563 } 14564 14565 case "FunctionName": 14566 if value != nil { 14567 jtv, ok := value.(string) 14568 if !ok { 14569 return fmt.Errorf("expected NamespacedFunctionName to be of type string, got %T instead", value) 14570 } 14571 sv.FunctionName = ptr.String(jtv) 14572 } 14573 14574 case "Handler": 14575 if value != nil { 14576 jtv, ok := value.(string) 14577 if !ok { 14578 return fmt.Errorf("expected Handler to be of type string, got %T instead", value) 14579 } 14580 sv.Handler = ptr.String(jtv) 14581 } 14582 14583 case "ImageConfigResponse": 14584 if err := awsRestjson1_deserializeDocumentImageConfigResponse(&sv.ImageConfigResponse, value); err != nil { 14585 return err 14586 } 14587 14588 case "KMSKeyArn": 14589 if value != nil { 14590 jtv, ok := value.(string) 14591 if !ok { 14592 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 14593 } 14594 sv.KMSKeyArn = ptr.String(jtv) 14595 } 14596 14597 case "LastModified": 14598 if value != nil { 14599 jtv, ok := value.(string) 14600 if !ok { 14601 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 14602 } 14603 sv.LastModified = ptr.String(jtv) 14604 } 14605 14606 case "LastUpdateStatus": 14607 if value != nil { 14608 jtv, ok := value.(string) 14609 if !ok { 14610 return fmt.Errorf("expected LastUpdateStatus to be of type string, got %T instead", value) 14611 } 14612 sv.LastUpdateStatus = types.LastUpdateStatus(jtv) 14613 } 14614 14615 case "LastUpdateStatusReason": 14616 if value != nil { 14617 jtv, ok := value.(string) 14618 if !ok { 14619 return fmt.Errorf("expected LastUpdateStatusReason to be of type string, got %T instead", value) 14620 } 14621 sv.LastUpdateStatusReason = ptr.String(jtv) 14622 } 14623 14624 case "LastUpdateStatusReasonCode": 14625 if value != nil { 14626 jtv, ok := value.(string) 14627 if !ok { 14628 return fmt.Errorf("expected LastUpdateStatusReasonCode to be of type string, got %T instead", value) 14629 } 14630 sv.LastUpdateStatusReasonCode = types.LastUpdateStatusReasonCode(jtv) 14631 } 14632 14633 case "Layers": 14634 if err := awsRestjson1_deserializeDocumentLayersReferenceList(&sv.Layers, value); err != nil { 14635 return err 14636 } 14637 14638 case "MasterArn": 14639 if value != nil { 14640 jtv, ok := value.(string) 14641 if !ok { 14642 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 14643 } 14644 sv.MasterArn = ptr.String(jtv) 14645 } 14646 14647 case "MemorySize": 14648 if value != nil { 14649 jtv, ok := value.(json.Number) 14650 if !ok { 14651 return fmt.Errorf("expected MemorySize to be json.Number, got %T instead", value) 14652 } 14653 i64, err := jtv.Int64() 14654 if err != nil { 14655 return err 14656 } 14657 sv.MemorySize = ptr.Int32(int32(i64)) 14658 } 14659 14660 case "PackageType": 14661 if value != nil { 14662 jtv, ok := value.(string) 14663 if !ok { 14664 return fmt.Errorf("expected PackageType to be of type string, got %T instead", value) 14665 } 14666 sv.PackageType = types.PackageType(jtv) 14667 } 14668 14669 case "RevisionId": 14670 if value != nil { 14671 jtv, ok := value.(string) 14672 if !ok { 14673 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14674 } 14675 sv.RevisionId = ptr.String(jtv) 14676 } 14677 14678 case "Role": 14679 if value != nil { 14680 jtv, ok := value.(string) 14681 if !ok { 14682 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 14683 } 14684 sv.Role = ptr.String(jtv) 14685 } 14686 14687 case "Runtime": 14688 if value != nil { 14689 jtv, ok := value.(string) 14690 if !ok { 14691 return fmt.Errorf("expected Runtime to be of type string, got %T instead", value) 14692 } 14693 sv.Runtime = types.Runtime(jtv) 14694 } 14695 14696 case "SigningJobArn": 14697 if value != nil { 14698 jtv, ok := value.(string) 14699 if !ok { 14700 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 14701 } 14702 sv.SigningJobArn = ptr.String(jtv) 14703 } 14704 14705 case "SigningProfileVersionArn": 14706 if value != nil { 14707 jtv, ok := value.(string) 14708 if !ok { 14709 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 14710 } 14711 sv.SigningProfileVersionArn = ptr.String(jtv) 14712 } 14713 14714 case "State": 14715 if value != nil { 14716 jtv, ok := value.(string) 14717 if !ok { 14718 return fmt.Errorf("expected State to be of type string, got %T instead", value) 14719 } 14720 sv.State = types.State(jtv) 14721 } 14722 14723 case "StateReason": 14724 if value != nil { 14725 jtv, ok := value.(string) 14726 if !ok { 14727 return fmt.Errorf("expected StateReason to be of type string, got %T instead", value) 14728 } 14729 sv.StateReason = ptr.String(jtv) 14730 } 14731 14732 case "StateReasonCode": 14733 if value != nil { 14734 jtv, ok := value.(string) 14735 if !ok { 14736 return fmt.Errorf("expected StateReasonCode to be of type string, got %T instead", value) 14737 } 14738 sv.StateReasonCode = types.StateReasonCode(jtv) 14739 } 14740 14741 case "Timeout": 14742 if value != nil { 14743 jtv, ok := value.(json.Number) 14744 if !ok { 14745 return fmt.Errorf("expected Timeout to be json.Number, got %T instead", value) 14746 } 14747 i64, err := jtv.Int64() 14748 if err != nil { 14749 return err 14750 } 14751 sv.Timeout = ptr.Int32(int32(i64)) 14752 } 14753 14754 case "TracingConfig": 14755 if err := awsRestjson1_deserializeDocumentTracingConfigResponse(&sv.TracingConfig, value); err != nil { 14756 return err 14757 } 14758 14759 case "Version": 14760 if value != nil { 14761 jtv, ok := value.(string) 14762 if !ok { 14763 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 14764 } 14765 sv.Version = ptr.String(jtv) 14766 } 14767 14768 case "VpcConfig": 14769 if err := awsRestjson1_deserializeDocumentVpcConfigResponse(&sv.VpcConfig, value); err != nil { 14770 return err 14771 } 14772 14773 default: 14774 _, _ = key, value 14775 14776 } 14777 } 14778 *v = sv 14779 return nil 14780} 14781 14782func awsRestjson1_deserializeDocumentFunctionEventInvokeConfig(v **types.FunctionEventInvokeConfig, value interface{}) error { 14783 if v == nil { 14784 return fmt.Errorf("unexpected nil of type %T", v) 14785 } 14786 if value == nil { 14787 return nil 14788 } 14789 14790 shape, ok := value.(map[string]interface{}) 14791 if !ok { 14792 return fmt.Errorf("unexpected JSON type %v", value) 14793 } 14794 14795 var sv *types.FunctionEventInvokeConfig 14796 if *v == nil { 14797 sv = &types.FunctionEventInvokeConfig{} 14798 } else { 14799 sv = *v 14800 } 14801 14802 for key, value := range shape { 14803 switch key { 14804 case "DestinationConfig": 14805 if err := awsRestjson1_deserializeDocumentDestinationConfig(&sv.DestinationConfig, value); err != nil { 14806 return err 14807 } 14808 14809 case "FunctionArn": 14810 if value != nil { 14811 jtv, ok := value.(string) 14812 if !ok { 14813 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 14814 } 14815 sv.FunctionArn = ptr.String(jtv) 14816 } 14817 14818 case "LastModified": 14819 if value != nil { 14820 jtv, ok := value.(json.Number) 14821 if !ok { 14822 return fmt.Errorf("expected Date to be json.Number, got %T instead", value) 14823 } 14824 f64, err := jtv.Float64() 14825 if err != nil { 14826 return err 14827 } 14828 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14829 } 14830 14831 case "MaximumEventAgeInSeconds": 14832 if value != nil { 14833 jtv, ok := value.(json.Number) 14834 if !ok { 14835 return fmt.Errorf("expected MaximumEventAgeInSeconds to be json.Number, got %T instead", value) 14836 } 14837 i64, err := jtv.Int64() 14838 if err != nil { 14839 return err 14840 } 14841 sv.MaximumEventAgeInSeconds = ptr.Int32(int32(i64)) 14842 } 14843 14844 case "MaximumRetryAttempts": 14845 if value != nil { 14846 jtv, ok := value.(json.Number) 14847 if !ok { 14848 return fmt.Errorf("expected MaximumRetryAttempts to be json.Number, got %T instead", value) 14849 } 14850 i64, err := jtv.Int64() 14851 if err != nil { 14852 return err 14853 } 14854 sv.MaximumRetryAttempts = ptr.Int32(int32(i64)) 14855 } 14856 14857 default: 14858 _, _ = key, value 14859 14860 } 14861 } 14862 *v = sv 14863 return nil 14864} 14865 14866func awsRestjson1_deserializeDocumentFunctionEventInvokeConfigList(v *[]types.FunctionEventInvokeConfig, value interface{}) error { 14867 if v == nil { 14868 return fmt.Errorf("unexpected nil of type %T", v) 14869 } 14870 if value == nil { 14871 return nil 14872 } 14873 14874 shape, ok := value.([]interface{}) 14875 if !ok { 14876 return fmt.Errorf("unexpected JSON type %v", value) 14877 } 14878 14879 var cv []types.FunctionEventInvokeConfig 14880 if *v == nil { 14881 cv = []types.FunctionEventInvokeConfig{} 14882 } else { 14883 cv = *v 14884 } 14885 14886 for _, value := range shape { 14887 var col types.FunctionEventInvokeConfig 14888 destAddr := &col 14889 if err := awsRestjson1_deserializeDocumentFunctionEventInvokeConfig(&destAddr, value); err != nil { 14890 return err 14891 } 14892 col = *destAddr 14893 cv = append(cv, col) 14894 14895 } 14896 *v = cv 14897 return nil 14898} 14899 14900func awsRestjson1_deserializeDocumentFunctionList(v *[]types.FunctionConfiguration, value interface{}) error { 14901 if v == nil { 14902 return fmt.Errorf("unexpected nil of type %T", v) 14903 } 14904 if value == nil { 14905 return nil 14906 } 14907 14908 shape, ok := value.([]interface{}) 14909 if !ok { 14910 return fmt.Errorf("unexpected JSON type %v", value) 14911 } 14912 14913 var cv []types.FunctionConfiguration 14914 if *v == nil { 14915 cv = []types.FunctionConfiguration{} 14916 } else { 14917 cv = *v 14918 } 14919 14920 for _, value := range shape { 14921 var col types.FunctionConfiguration 14922 destAddr := &col 14923 if err := awsRestjson1_deserializeDocumentFunctionConfiguration(&destAddr, value); err != nil { 14924 return err 14925 } 14926 col = *destAddr 14927 cv = append(cv, col) 14928 14929 } 14930 *v = cv 14931 return nil 14932} 14933 14934func awsRestjson1_deserializeDocumentFunctionResponseTypeList(v *[]types.FunctionResponseType, value interface{}) error { 14935 if v == nil { 14936 return fmt.Errorf("unexpected nil of type %T", v) 14937 } 14938 if value == nil { 14939 return nil 14940 } 14941 14942 shape, ok := value.([]interface{}) 14943 if !ok { 14944 return fmt.Errorf("unexpected JSON type %v", value) 14945 } 14946 14947 var cv []types.FunctionResponseType 14948 if *v == nil { 14949 cv = []types.FunctionResponseType{} 14950 } else { 14951 cv = *v 14952 } 14953 14954 for _, value := range shape { 14955 var col types.FunctionResponseType 14956 if value != nil { 14957 jtv, ok := value.(string) 14958 if !ok { 14959 return fmt.Errorf("expected FunctionResponseType to be of type string, got %T instead", value) 14960 } 14961 col = types.FunctionResponseType(jtv) 14962 } 14963 cv = append(cv, col) 14964 14965 } 14966 *v = cv 14967 return nil 14968} 14969 14970func awsRestjson1_deserializeDocumentImageConfig(v **types.ImageConfig, value interface{}) error { 14971 if v == nil { 14972 return fmt.Errorf("unexpected nil of type %T", v) 14973 } 14974 if value == nil { 14975 return nil 14976 } 14977 14978 shape, ok := value.(map[string]interface{}) 14979 if !ok { 14980 return fmt.Errorf("unexpected JSON type %v", value) 14981 } 14982 14983 var sv *types.ImageConfig 14984 if *v == nil { 14985 sv = &types.ImageConfig{} 14986 } else { 14987 sv = *v 14988 } 14989 14990 for key, value := range shape { 14991 switch key { 14992 case "Command": 14993 if err := awsRestjson1_deserializeDocumentStringList(&sv.Command, value); err != nil { 14994 return err 14995 } 14996 14997 case "EntryPoint": 14998 if err := awsRestjson1_deserializeDocumentStringList(&sv.EntryPoint, value); err != nil { 14999 return err 15000 } 15001 15002 case "WorkingDirectory": 15003 if value != nil { 15004 jtv, ok := value.(string) 15005 if !ok { 15006 return fmt.Errorf("expected WorkingDirectory to be of type string, got %T instead", value) 15007 } 15008 sv.WorkingDirectory = ptr.String(jtv) 15009 } 15010 15011 default: 15012 _, _ = key, value 15013 15014 } 15015 } 15016 *v = sv 15017 return nil 15018} 15019 15020func awsRestjson1_deserializeDocumentImageConfigError(v **types.ImageConfigError, value interface{}) error { 15021 if v == nil { 15022 return fmt.Errorf("unexpected nil of type %T", v) 15023 } 15024 if value == nil { 15025 return nil 15026 } 15027 15028 shape, ok := value.(map[string]interface{}) 15029 if !ok { 15030 return fmt.Errorf("unexpected JSON type %v", value) 15031 } 15032 15033 var sv *types.ImageConfigError 15034 if *v == nil { 15035 sv = &types.ImageConfigError{} 15036 } else { 15037 sv = *v 15038 } 15039 15040 for key, value := range shape { 15041 switch key { 15042 case "ErrorCode": 15043 if value != nil { 15044 jtv, ok := value.(string) 15045 if !ok { 15046 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15047 } 15048 sv.ErrorCode = ptr.String(jtv) 15049 } 15050 15051 case "Message": 15052 if value != nil { 15053 jtv, ok := value.(string) 15054 if !ok { 15055 return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value) 15056 } 15057 sv.Message = ptr.String(jtv) 15058 } 15059 15060 default: 15061 _, _ = key, value 15062 15063 } 15064 } 15065 *v = sv 15066 return nil 15067} 15068 15069func awsRestjson1_deserializeDocumentImageConfigResponse(v **types.ImageConfigResponse, value interface{}) error { 15070 if v == nil { 15071 return fmt.Errorf("unexpected nil of type %T", v) 15072 } 15073 if value == nil { 15074 return nil 15075 } 15076 15077 shape, ok := value.(map[string]interface{}) 15078 if !ok { 15079 return fmt.Errorf("unexpected JSON type %v", value) 15080 } 15081 15082 var sv *types.ImageConfigResponse 15083 if *v == nil { 15084 sv = &types.ImageConfigResponse{} 15085 } else { 15086 sv = *v 15087 } 15088 15089 for key, value := range shape { 15090 switch key { 15091 case "Error": 15092 if err := awsRestjson1_deserializeDocumentImageConfigError(&sv.Error, value); err != nil { 15093 return err 15094 } 15095 15096 case "ImageConfig": 15097 if err := awsRestjson1_deserializeDocumentImageConfig(&sv.ImageConfig, value); err != nil { 15098 return err 15099 } 15100 15101 default: 15102 _, _ = key, value 15103 15104 } 15105 } 15106 *v = sv 15107 return nil 15108} 15109 15110func awsRestjson1_deserializeDocumentInvalidCodeSignatureException(v **types.InvalidCodeSignatureException, value interface{}) error { 15111 if v == nil { 15112 return fmt.Errorf("unexpected nil of type %T", v) 15113 } 15114 if value == nil { 15115 return nil 15116 } 15117 15118 shape, ok := value.(map[string]interface{}) 15119 if !ok { 15120 return fmt.Errorf("unexpected JSON type %v", value) 15121 } 15122 15123 var sv *types.InvalidCodeSignatureException 15124 if *v == nil { 15125 sv = &types.InvalidCodeSignatureException{} 15126 } else { 15127 sv = *v 15128 } 15129 15130 for key, value := range shape { 15131 switch key { 15132 case "Message": 15133 if value != nil { 15134 jtv, ok := value.(string) 15135 if !ok { 15136 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15137 } 15138 sv.Message = ptr.String(jtv) 15139 } 15140 15141 case "Type": 15142 if value != nil { 15143 jtv, ok := value.(string) 15144 if !ok { 15145 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15146 } 15147 sv.Type = ptr.String(jtv) 15148 } 15149 15150 default: 15151 _, _ = key, value 15152 15153 } 15154 } 15155 *v = sv 15156 return nil 15157} 15158 15159func awsRestjson1_deserializeDocumentInvalidParameterValueException(v **types.InvalidParameterValueException, value interface{}) error { 15160 if v == nil { 15161 return fmt.Errorf("unexpected nil of type %T", v) 15162 } 15163 if value == nil { 15164 return nil 15165 } 15166 15167 shape, ok := value.(map[string]interface{}) 15168 if !ok { 15169 return fmt.Errorf("unexpected JSON type %v", value) 15170 } 15171 15172 var sv *types.InvalidParameterValueException 15173 if *v == nil { 15174 sv = &types.InvalidParameterValueException{} 15175 } else { 15176 sv = *v 15177 } 15178 15179 for key, value := range shape { 15180 switch key { 15181 case "message": 15182 if value != nil { 15183 jtv, ok := value.(string) 15184 if !ok { 15185 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15186 } 15187 sv.Message = ptr.String(jtv) 15188 } 15189 15190 case "Type": 15191 if value != nil { 15192 jtv, ok := value.(string) 15193 if !ok { 15194 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15195 } 15196 sv.Type = ptr.String(jtv) 15197 } 15198 15199 default: 15200 _, _ = key, value 15201 15202 } 15203 } 15204 *v = sv 15205 return nil 15206} 15207 15208func awsRestjson1_deserializeDocumentInvalidRequestContentException(v **types.InvalidRequestContentException, value interface{}) error { 15209 if v == nil { 15210 return fmt.Errorf("unexpected nil of type %T", v) 15211 } 15212 if value == nil { 15213 return nil 15214 } 15215 15216 shape, ok := value.(map[string]interface{}) 15217 if !ok { 15218 return fmt.Errorf("unexpected JSON type %v", value) 15219 } 15220 15221 var sv *types.InvalidRequestContentException 15222 if *v == nil { 15223 sv = &types.InvalidRequestContentException{} 15224 } else { 15225 sv = *v 15226 } 15227 15228 for key, value := range shape { 15229 switch key { 15230 case "message": 15231 if value != nil { 15232 jtv, ok := value.(string) 15233 if !ok { 15234 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15235 } 15236 sv.Message = ptr.String(jtv) 15237 } 15238 15239 case "Type": 15240 if value != nil { 15241 jtv, ok := value.(string) 15242 if !ok { 15243 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15244 } 15245 sv.Type = ptr.String(jtv) 15246 } 15247 15248 default: 15249 _, _ = key, value 15250 15251 } 15252 } 15253 *v = sv 15254 return nil 15255} 15256 15257func awsRestjson1_deserializeDocumentInvalidRuntimeException(v **types.InvalidRuntimeException, value interface{}) error { 15258 if v == nil { 15259 return fmt.Errorf("unexpected nil of type %T", v) 15260 } 15261 if value == nil { 15262 return nil 15263 } 15264 15265 shape, ok := value.(map[string]interface{}) 15266 if !ok { 15267 return fmt.Errorf("unexpected JSON type %v", value) 15268 } 15269 15270 var sv *types.InvalidRuntimeException 15271 if *v == nil { 15272 sv = &types.InvalidRuntimeException{} 15273 } else { 15274 sv = *v 15275 } 15276 15277 for key, value := range shape { 15278 switch key { 15279 case "Message": 15280 if value != nil { 15281 jtv, ok := value.(string) 15282 if !ok { 15283 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15284 } 15285 sv.Message = ptr.String(jtv) 15286 } 15287 15288 case "Type": 15289 if value != nil { 15290 jtv, ok := value.(string) 15291 if !ok { 15292 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15293 } 15294 sv.Type = ptr.String(jtv) 15295 } 15296 15297 default: 15298 _, _ = key, value 15299 15300 } 15301 } 15302 *v = sv 15303 return nil 15304} 15305 15306func awsRestjson1_deserializeDocumentInvalidSecurityGroupIDException(v **types.InvalidSecurityGroupIDException, value interface{}) error { 15307 if v == nil { 15308 return fmt.Errorf("unexpected nil of type %T", v) 15309 } 15310 if value == nil { 15311 return nil 15312 } 15313 15314 shape, ok := value.(map[string]interface{}) 15315 if !ok { 15316 return fmt.Errorf("unexpected JSON type %v", value) 15317 } 15318 15319 var sv *types.InvalidSecurityGroupIDException 15320 if *v == nil { 15321 sv = &types.InvalidSecurityGroupIDException{} 15322 } else { 15323 sv = *v 15324 } 15325 15326 for key, value := range shape { 15327 switch key { 15328 case "Message": 15329 if value != nil { 15330 jtv, ok := value.(string) 15331 if !ok { 15332 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15333 } 15334 sv.Message = ptr.String(jtv) 15335 } 15336 15337 case "Type": 15338 if value != nil { 15339 jtv, ok := value.(string) 15340 if !ok { 15341 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15342 } 15343 sv.Type = ptr.String(jtv) 15344 } 15345 15346 default: 15347 _, _ = key, value 15348 15349 } 15350 } 15351 *v = sv 15352 return nil 15353} 15354 15355func awsRestjson1_deserializeDocumentInvalidSubnetIDException(v **types.InvalidSubnetIDException, value interface{}) error { 15356 if v == nil { 15357 return fmt.Errorf("unexpected nil of type %T", v) 15358 } 15359 if value == nil { 15360 return nil 15361 } 15362 15363 shape, ok := value.(map[string]interface{}) 15364 if !ok { 15365 return fmt.Errorf("unexpected JSON type %v", value) 15366 } 15367 15368 var sv *types.InvalidSubnetIDException 15369 if *v == nil { 15370 sv = &types.InvalidSubnetIDException{} 15371 } else { 15372 sv = *v 15373 } 15374 15375 for key, value := range shape { 15376 switch key { 15377 case "Message": 15378 if value != nil { 15379 jtv, ok := value.(string) 15380 if !ok { 15381 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15382 } 15383 sv.Message = ptr.String(jtv) 15384 } 15385 15386 case "Type": 15387 if value != nil { 15388 jtv, ok := value.(string) 15389 if !ok { 15390 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15391 } 15392 sv.Type = ptr.String(jtv) 15393 } 15394 15395 default: 15396 _, _ = key, value 15397 15398 } 15399 } 15400 *v = sv 15401 return nil 15402} 15403 15404func awsRestjson1_deserializeDocumentInvalidZipFileException(v **types.InvalidZipFileException, value interface{}) error { 15405 if v == nil { 15406 return fmt.Errorf("unexpected nil of type %T", v) 15407 } 15408 if value == nil { 15409 return nil 15410 } 15411 15412 shape, ok := value.(map[string]interface{}) 15413 if !ok { 15414 return fmt.Errorf("unexpected JSON type %v", value) 15415 } 15416 15417 var sv *types.InvalidZipFileException 15418 if *v == nil { 15419 sv = &types.InvalidZipFileException{} 15420 } else { 15421 sv = *v 15422 } 15423 15424 for key, value := range shape { 15425 switch key { 15426 case "Message": 15427 if value != nil { 15428 jtv, ok := value.(string) 15429 if !ok { 15430 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15431 } 15432 sv.Message = ptr.String(jtv) 15433 } 15434 15435 case "Type": 15436 if value != nil { 15437 jtv, ok := value.(string) 15438 if !ok { 15439 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15440 } 15441 sv.Type = ptr.String(jtv) 15442 } 15443 15444 default: 15445 _, _ = key, value 15446 15447 } 15448 } 15449 *v = sv 15450 return nil 15451} 15452 15453func awsRestjson1_deserializeDocumentKMSAccessDeniedException(v **types.KMSAccessDeniedException, value interface{}) error { 15454 if v == nil { 15455 return fmt.Errorf("unexpected nil of type %T", v) 15456 } 15457 if value == nil { 15458 return nil 15459 } 15460 15461 shape, ok := value.(map[string]interface{}) 15462 if !ok { 15463 return fmt.Errorf("unexpected JSON type %v", value) 15464 } 15465 15466 var sv *types.KMSAccessDeniedException 15467 if *v == nil { 15468 sv = &types.KMSAccessDeniedException{} 15469 } else { 15470 sv = *v 15471 } 15472 15473 for key, value := range shape { 15474 switch key { 15475 case "Message": 15476 if value != nil { 15477 jtv, ok := value.(string) 15478 if !ok { 15479 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15480 } 15481 sv.Message = ptr.String(jtv) 15482 } 15483 15484 case "Type": 15485 if value != nil { 15486 jtv, ok := value.(string) 15487 if !ok { 15488 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15489 } 15490 sv.Type = ptr.String(jtv) 15491 } 15492 15493 default: 15494 _, _ = key, value 15495 15496 } 15497 } 15498 *v = sv 15499 return nil 15500} 15501 15502func awsRestjson1_deserializeDocumentKMSDisabledException(v **types.KMSDisabledException, value interface{}) error { 15503 if v == nil { 15504 return fmt.Errorf("unexpected nil of type %T", v) 15505 } 15506 if value == nil { 15507 return nil 15508 } 15509 15510 shape, ok := value.(map[string]interface{}) 15511 if !ok { 15512 return fmt.Errorf("unexpected JSON type %v", value) 15513 } 15514 15515 var sv *types.KMSDisabledException 15516 if *v == nil { 15517 sv = &types.KMSDisabledException{} 15518 } else { 15519 sv = *v 15520 } 15521 15522 for key, value := range shape { 15523 switch key { 15524 case "Message": 15525 if value != nil { 15526 jtv, ok := value.(string) 15527 if !ok { 15528 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15529 } 15530 sv.Message = ptr.String(jtv) 15531 } 15532 15533 case "Type": 15534 if value != nil { 15535 jtv, ok := value.(string) 15536 if !ok { 15537 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15538 } 15539 sv.Type = ptr.String(jtv) 15540 } 15541 15542 default: 15543 _, _ = key, value 15544 15545 } 15546 } 15547 *v = sv 15548 return nil 15549} 15550 15551func awsRestjson1_deserializeDocumentKMSInvalidStateException(v **types.KMSInvalidStateException, value interface{}) error { 15552 if v == nil { 15553 return fmt.Errorf("unexpected nil of type %T", v) 15554 } 15555 if value == nil { 15556 return nil 15557 } 15558 15559 shape, ok := value.(map[string]interface{}) 15560 if !ok { 15561 return fmt.Errorf("unexpected JSON type %v", value) 15562 } 15563 15564 var sv *types.KMSInvalidStateException 15565 if *v == nil { 15566 sv = &types.KMSInvalidStateException{} 15567 } else { 15568 sv = *v 15569 } 15570 15571 for key, value := range shape { 15572 switch key { 15573 case "Message": 15574 if value != nil { 15575 jtv, ok := value.(string) 15576 if !ok { 15577 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15578 } 15579 sv.Message = ptr.String(jtv) 15580 } 15581 15582 case "Type": 15583 if value != nil { 15584 jtv, ok := value.(string) 15585 if !ok { 15586 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15587 } 15588 sv.Type = ptr.String(jtv) 15589 } 15590 15591 default: 15592 _, _ = key, value 15593 15594 } 15595 } 15596 *v = sv 15597 return nil 15598} 15599 15600func awsRestjson1_deserializeDocumentKMSNotFoundException(v **types.KMSNotFoundException, value interface{}) error { 15601 if v == nil { 15602 return fmt.Errorf("unexpected nil of type %T", v) 15603 } 15604 if value == nil { 15605 return nil 15606 } 15607 15608 shape, ok := value.(map[string]interface{}) 15609 if !ok { 15610 return fmt.Errorf("unexpected JSON type %v", value) 15611 } 15612 15613 var sv *types.KMSNotFoundException 15614 if *v == nil { 15615 sv = &types.KMSNotFoundException{} 15616 } else { 15617 sv = *v 15618 } 15619 15620 for key, value := range shape { 15621 switch key { 15622 case "Message": 15623 if value != nil { 15624 jtv, ok := value.(string) 15625 if !ok { 15626 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15627 } 15628 sv.Message = ptr.String(jtv) 15629 } 15630 15631 case "Type": 15632 if value != nil { 15633 jtv, ok := value.(string) 15634 if !ok { 15635 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15636 } 15637 sv.Type = ptr.String(jtv) 15638 } 15639 15640 default: 15641 _, _ = key, value 15642 15643 } 15644 } 15645 *v = sv 15646 return nil 15647} 15648 15649func awsRestjson1_deserializeDocumentLayer(v **types.Layer, value interface{}) error { 15650 if v == nil { 15651 return fmt.Errorf("unexpected nil of type %T", v) 15652 } 15653 if value == nil { 15654 return nil 15655 } 15656 15657 shape, ok := value.(map[string]interface{}) 15658 if !ok { 15659 return fmt.Errorf("unexpected JSON type %v", value) 15660 } 15661 15662 var sv *types.Layer 15663 if *v == nil { 15664 sv = &types.Layer{} 15665 } else { 15666 sv = *v 15667 } 15668 15669 for key, value := range shape { 15670 switch key { 15671 case "Arn": 15672 if value != nil { 15673 jtv, ok := value.(string) 15674 if !ok { 15675 return fmt.Errorf("expected LayerVersionArn to be of type string, got %T instead", value) 15676 } 15677 sv.Arn = ptr.String(jtv) 15678 } 15679 15680 case "CodeSize": 15681 if value != nil { 15682 jtv, ok := value.(json.Number) 15683 if !ok { 15684 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 15685 } 15686 i64, err := jtv.Int64() 15687 if err != nil { 15688 return err 15689 } 15690 sv.CodeSize = i64 15691 } 15692 15693 case "SigningJobArn": 15694 if value != nil { 15695 jtv, ok := value.(string) 15696 if !ok { 15697 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 15698 } 15699 sv.SigningJobArn = ptr.String(jtv) 15700 } 15701 15702 case "SigningProfileVersionArn": 15703 if value != nil { 15704 jtv, ok := value.(string) 15705 if !ok { 15706 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 15707 } 15708 sv.SigningProfileVersionArn = ptr.String(jtv) 15709 } 15710 15711 default: 15712 _, _ = key, value 15713 15714 } 15715 } 15716 *v = sv 15717 return nil 15718} 15719 15720func awsRestjson1_deserializeDocumentLayersList(v *[]types.LayersListItem, value interface{}) error { 15721 if v == nil { 15722 return fmt.Errorf("unexpected nil of type %T", v) 15723 } 15724 if value == nil { 15725 return nil 15726 } 15727 15728 shape, ok := value.([]interface{}) 15729 if !ok { 15730 return fmt.Errorf("unexpected JSON type %v", value) 15731 } 15732 15733 var cv []types.LayersListItem 15734 if *v == nil { 15735 cv = []types.LayersListItem{} 15736 } else { 15737 cv = *v 15738 } 15739 15740 for _, value := range shape { 15741 var col types.LayersListItem 15742 destAddr := &col 15743 if err := awsRestjson1_deserializeDocumentLayersListItem(&destAddr, value); err != nil { 15744 return err 15745 } 15746 col = *destAddr 15747 cv = append(cv, col) 15748 15749 } 15750 *v = cv 15751 return nil 15752} 15753 15754func awsRestjson1_deserializeDocumentLayersListItem(v **types.LayersListItem, value interface{}) error { 15755 if v == nil { 15756 return fmt.Errorf("unexpected nil of type %T", v) 15757 } 15758 if value == nil { 15759 return nil 15760 } 15761 15762 shape, ok := value.(map[string]interface{}) 15763 if !ok { 15764 return fmt.Errorf("unexpected JSON type %v", value) 15765 } 15766 15767 var sv *types.LayersListItem 15768 if *v == nil { 15769 sv = &types.LayersListItem{} 15770 } else { 15771 sv = *v 15772 } 15773 15774 for key, value := range shape { 15775 switch key { 15776 case "LatestMatchingVersion": 15777 if err := awsRestjson1_deserializeDocumentLayerVersionsListItem(&sv.LatestMatchingVersion, value); err != nil { 15778 return err 15779 } 15780 15781 case "LayerArn": 15782 if value != nil { 15783 jtv, ok := value.(string) 15784 if !ok { 15785 return fmt.Errorf("expected LayerArn to be of type string, got %T instead", value) 15786 } 15787 sv.LayerArn = ptr.String(jtv) 15788 } 15789 15790 case "LayerName": 15791 if value != nil { 15792 jtv, ok := value.(string) 15793 if !ok { 15794 return fmt.Errorf("expected LayerName to be of type string, got %T instead", value) 15795 } 15796 sv.LayerName = ptr.String(jtv) 15797 } 15798 15799 default: 15800 _, _ = key, value 15801 15802 } 15803 } 15804 *v = sv 15805 return nil 15806} 15807 15808func awsRestjson1_deserializeDocumentLayersReferenceList(v *[]types.Layer, value interface{}) error { 15809 if v == nil { 15810 return fmt.Errorf("unexpected nil of type %T", v) 15811 } 15812 if value == nil { 15813 return nil 15814 } 15815 15816 shape, ok := value.([]interface{}) 15817 if !ok { 15818 return fmt.Errorf("unexpected JSON type %v", value) 15819 } 15820 15821 var cv []types.Layer 15822 if *v == nil { 15823 cv = []types.Layer{} 15824 } else { 15825 cv = *v 15826 } 15827 15828 for _, value := range shape { 15829 var col types.Layer 15830 destAddr := &col 15831 if err := awsRestjson1_deserializeDocumentLayer(&destAddr, value); err != nil { 15832 return err 15833 } 15834 col = *destAddr 15835 cv = append(cv, col) 15836 15837 } 15838 *v = cv 15839 return nil 15840} 15841 15842func awsRestjson1_deserializeDocumentLayerVersionContentOutput(v **types.LayerVersionContentOutput, value interface{}) error { 15843 if v == nil { 15844 return fmt.Errorf("unexpected nil of type %T", v) 15845 } 15846 if value == nil { 15847 return nil 15848 } 15849 15850 shape, ok := value.(map[string]interface{}) 15851 if !ok { 15852 return fmt.Errorf("unexpected JSON type %v", value) 15853 } 15854 15855 var sv *types.LayerVersionContentOutput 15856 if *v == nil { 15857 sv = &types.LayerVersionContentOutput{} 15858 } else { 15859 sv = *v 15860 } 15861 15862 for key, value := range shape { 15863 switch key { 15864 case "CodeSha256": 15865 if value != nil { 15866 jtv, ok := value.(string) 15867 if !ok { 15868 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15869 } 15870 sv.CodeSha256 = ptr.String(jtv) 15871 } 15872 15873 case "CodeSize": 15874 if value != nil { 15875 jtv, ok := value.(json.Number) 15876 if !ok { 15877 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 15878 } 15879 i64, err := jtv.Int64() 15880 if err != nil { 15881 return err 15882 } 15883 sv.CodeSize = i64 15884 } 15885 15886 case "Location": 15887 if value != nil { 15888 jtv, ok := value.(string) 15889 if !ok { 15890 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15891 } 15892 sv.Location = ptr.String(jtv) 15893 } 15894 15895 case "SigningJobArn": 15896 if value != nil { 15897 jtv, ok := value.(string) 15898 if !ok { 15899 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15900 } 15901 sv.SigningJobArn = ptr.String(jtv) 15902 } 15903 15904 case "SigningProfileVersionArn": 15905 if value != nil { 15906 jtv, ok := value.(string) 15907 if !ok { 15908 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15909 } 15910 sv.SigningProfileVersionArn = ptr.String(jtv) 15911 } 15912 15913 default: 15914 _, _ = key, value 15915 15916 } 15917 } 15918 *v = sv 15919 return nil 15920} 15921 15922func awsRestjson1_deserializeDocumentLayerVersionsList(v *[]types.LayerVersionsListItem, value interface{}) error { 15923 if v == nil { 15924 return fmt.Errorf("unexpected nil of type %T", v) 15925 } 15926 if value == nil { 15927 return nil 15928 } 15929 15930 shape, ok := value.([]interface{}) 15931 if !ok { 15932 return fmt.Errorf("unexpected JSON type %v", value) 15933 } 15934 15935 var cv []types.LayerVersionsListItem 15936 if *v == nil { 15937 cv = []types.LayerVersionsListItem{} 15938 } else { 15939 cv = *v 15940 } 15941 15942 for _, value := range shape { 15943 var col types.LayerVersionsListItem 15944 destAddr := &col 15945 if err := awsRestjson1_deserializeDocumentLayerVersionsListItem(&destAddr, value); err != nil { 15946 return err 15947 } 15948 col = *destAddr 15949 cv = append(cv, col) 15950 15951 } 15952 *v = cv 15953 return nil 15954} 15955 15956func awsRestjson1_deserializeDocumentLayerVersionsListItem(v **types.LayerVersionsListItem, value interface{}) error { 15957 if v == nil { 15958 return fmt.Errorf("unexpected nil of type %T", v) 15959 } 15960 if value == nil { 15961 return nil 15962 } 15963 15964 shape, ok := value.(map[string]interface{}) 15965 if !ok { 15966 return fmt.Errorf("unexpected JSON type %v", value) 15967 } 15968 15969 var sv *types.LayerVersionsListItem 15970 if *v == nil { 15971 sv = &types.LayerVersionsListItem{} 15972 } else { 15973 sv = *v 15974 } 15975 15976 for key, value := range shape { 15977 switch key { 15978 case "CompatibleRuntimes": 15979 if err := awsRestjson1_deserializeDocumentCompatibleRuntimes(&sv.CompatibleRuntimes, value); err != nil { 15980 return err 15981 } 15982 15983 case "CreatedDate": 15984 if value != nil { 15985 jtv, ok := value.(string) 15986 if !ok { 15987 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 15988 } 15989 sv.CreatedDate = ptr.String(jtv) 15990 } 15991 15992 case "Description": 15993 if value != nil { 15994 jtv, ok := value.(string) 15995 if !ok { 15996 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 15997 } 15998 sv.Description = ptr.String(jtv) 15999 } 16000 16001 case "LayerVersionArn": 16002 if value != nil { 16003 jtv, ok := value.(string) 16004 if !ok { 16005 return fmt.Errorf("expected LayerVersionArn to be of type string, got %T instead", value) 16006 } 16007 sv.LayerVersionArn = ptr.String(jtv) 16008 } 16009 16010 case "LicenseInfo": 16011 if value != nil { 16012 jtv, ok := value.(string) 16013 if !ok { 16014 return fmt.Errorf("expected LicenseInfo to be of type string, got %T instead", value) 16015 } 16016 sv.LicenseInfo = ptr.String(jtv) 16017 } 16018 16019 case "Version": 16020 if value != nil { 16021 jtv, ok := value.(json.Number) 16022 if !ok { 16023 return fmt.Errorf("expected LayerVersionNumber to be json.Number, got %T instead", value) 16024 } 16025 i64, err := jtv.Int64() 16026 if err != nil { 16027 return err 16028 } 16029 sv.Version = i64 16030 } 16031 16032 default: 16033 _, _ = key, value 16034 16035 } 16036 } 16037 *v = sv 16038 return nil 16039} 16040 16041func awsRestjson1_deserializeDocumentOnFailure(v **types.OnFailure, value interface{}) error { 16042 if v == nil { 16043 return fmt.Errorf("unexpected nil of type %T", v) 16044 } 16045 if value == nil { 16046 return nil 16047 } 16048 16049 shape, ok := value.(map[string]interface{}) 16050 if !ok { 16051 return fmt.Errorf("unexpected JSON type %v", value) 16052 } 16053 16054 var sv *types.OnFailure 16055 if *v == nil { 16056 sv = &types.OnFailure{} 16057 } else { 16058 sv = *v 16059 } 16060 16061 for key, value := range shape { 16062 switch key { 16063 case "Destination": 16064 if value != nil { 16065 jtv, ok := value.(string) 16066 if !ok { 16067 return fmt.Errorf("expected DestinationArn to be of type string, got %T instead", value) 16068 } 16069 sv.Destination = ptr.String(jtv) 16070 } 16071 16072 default: 16073 _, _ = key, value 16074 16075 } 16076 } 16077 *v = sv 16078 return nil 16079} 16080 16081func awsRestjson1_deserializeDocumentOnSuccess(v **types.OnSuccess, value interface{}) error { 16082 if v == nil { 16083 return fmt.Errorf("unexpected nil of type %T", v) 16084 } 16085 if value == nil { 16086 return nil 16087 } 16088 16089 shape, ok := value.(map[string]interface{}) 16090 if !ok { 16091 return fmt.Errorf("unexpected JSON type %v", value) 16092 } 16093 16094 var sv *types.OnSuccess 16095 if *v == nil { 16096 sv = &types.OnSuccess{} 16097 } else { 16098 sv = *v 16099 } 16100 16101 for key, value := range shape { 16102 switch key { 16103 case "Destination": 16104 if value != nil { 16105 jtv, ok := value.(string) 16106 if !ok { 16107 return fmt.Errorf("expected DestinationArn to be of type string, got %T instead", value) 16108 } 16109 sv.Destination = ptr.String(jtv) 16110 } 16111 16112 default: 16113 _, _ = key, value 16114 16115 } 16116 } 16117 *v = sv 16118 return nil 16119} 16120 16121func awsRestjson1_deserializeDocumentPolicyLengthExceededException(v **types.PolicyLengthExceededException, value interface{}) error { 16122 if v == nil { 16123 return fmt.Errorf("unexpected nil of type %T", v) 16124 } 16125 if value == nil { 16126 return nil 16127 } 16128 16129 shape, ok := value.(map[string]interface{}) 16130 if !ok { 16131 return fmt.Errorf("unexpected JSON type %v", value) 16132 } 16133 16134 var sv *types.PolicyLengthExceededException 16135 if *v == nil { 16136 sv = &types.PolicyLengthExceededException{} 16137 } else { 16138 sv = *v 16139 } 16140 16141 for key, value := range shape { 16142 switch key { 16143 case "message": 16144 if value != nil { 16145 jtv, ok := value.(string) 16146 if !ok { 16147 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16148 } 16149 sv.Message = ptr.String(jtv) 16150 } 16151 16152 case "Type": 16153 if value != nil { 16154 jtv, ok := value.(string) 16155 if !ok { 16156 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16157 } 16158 sv.Type = ptr.String(jtv) 16159 } 16160 16161 default: 16162 _, _ = key, value 16163 16164 } 16165 } 16166 *v = sv 16167 return nil 16168} 16169 16170func awsRestjson1_deserializeDocumentPreconditionFailedException(v **types.PreconditionFailedException, value interface{}) error { 16171 if v == nil { 16172 return fmt.Errorf("unexpected nil of type %T", v) 16173 } 16174 if value == nil { 16175 return nil 16176 } 16177 16178 shape, ok := value.(map[string]interface{}) 16179 if !ok { 16180 return fmt.Errorf("unexpected JSON type %v", value) 16181 } 16182 16183 var sv *types.PreconditionFailedException 16184 if *v == nil { 16185 sv = &types.PreconditionFailedException{} 16186 } else { 16187 sv = *v 16188 } 16189 16190 for key, value := range shape { 16191 switch key { 16192 case "message": 16193 if value != nil { 16194 jtv, ok := value.(string) 16195 if !ok { 16196 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16197 } 16198 sv.Message = ptr.String(jtv) 16199 } 16200 16201 case "Type": 16202 if value != nil { 16203 jtv, ok := value.(string) 16204 if !ok { 16205 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16206 } 16207 sv.Type = ptr.String(jtv) 16208 } 16209 16210 default: 16211 _, _ = key, value 16212 16213 } 16214 } 16215 *v = sv 16216 return nil 16217} 16218 16219func awsRestjson1_deserializeDocumentProvisionedConcurrencyConfigList(v *[]types.ProvisionedConcurrencyConfigListItem, value interface{}) error { 16220 if v == nil { 16221 return fmt.Errorf("unexpected nil of type %T", v) 16222 } 16223 if value == nil { 16224 return nil 16225 } 16226 16227 shape, ok := value.([]interface{}) 16228 if !ok { 16229 return fmt.Errorf("unexpected JSON type %v", value) 16230 } 16231 16232 var cv []types.ProvisionedConcurrencyConfigListItem 16233 if *v == nil { 16234 cv = []types.ProvisionedConcurrencyConfigListItem{} 16235 } else { 16236 cv = *v 16237 } 16238 16239 for _, value := range shape { 16240 var col types.ProvisionedConcurrencyConfigListItem 16241 destAddr := &col 16242 if err := awsRestjson1_deserializeDocumentProvisionedConcurrencyConfigListItem(&destAddr, value); err != nil { 16243 return err 16244 } 16245 col = *destAddr 16246 cv = append(cv, col) 16247 16248 } 16249 *v = cv 16250 return nil 16251} 16252 16253func awsRestjson1_deserializeDocumentProvisionedConcurrencyConfigListItem(v **types.ProvisionedConcurrencyConfigListItem, value interface{}) error { 16254 if v == nil { 16255 return fmt.Errorf("unexpected nil of type %T", v) 16256 } 16257 if value == nil { 16258 return nil 16259 } 16260 16261 shape, ok := value.(map[string]interface{}) 16262 if !ok { 16263 return fmt.Errorf("unexpected JSON type %v", value) 16264 } 16265 16266 var sv *types.ProvisionedConcurrencyConfigListItem 16267 if *v == nil { 16268 sv = &types.ProvisionedConcurrencyConfigListItem{} 16269 } else { 16270 sv = *v 16271 } 16272 16273 for key, value := range shape { 16274 switch key { 16275 case "AllocatedProvisionedConcurrentExecutions": 16276 if value != nil { 16277 jtv, ok := value.(json.Number) 16278 if !ok { 16279 return fmt.Errorf("expected NonNegativeInteger to be json.Number, got %T instead", value) 16280 } 16281 i64, err := jtv.Int64() 16282 if err != nil { 16283 return err 16284 } 16285 sv.AllocatedProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 16286 } 16287 16288 case "AvailableProvisionedConcurrentExecutions": 16289 if value != nil { 16290 jtv, ok := value.(json.Number) 16291 if !ok { 16292 return fmt.Errorf("expected NonNegativeInteger to be json.Number, got %T instead", value) 16293 } 16294 i64, err := jtv.Int64() 16295 if err != nil { 16296 return err 16297 } 16298 sv.AvailableProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 16299 } 16300 16301 case "FunctionArn": 16302 if value != nil { 16303 jtv, ok := value.(string) 16304 if !ok { 16305 return fmt.Errorf("expected FunctionArn to be of type string, got %T instead", value) 16306 } 16307 sv.FunctionArn = ptr.String(jtv) 16308 } 16309 16310 case "LastModified": 16311 if value != nil { 16312 jtv, ok := value.(string) 16313 if !ok { 16314 return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value) 16315 } 16316 sv.LastModified = ptr.String(jtv) 16317 } 16318 16319 case "RequestedProvisionedConcurrentExecutions": 16320 if value != nil { 16321 jtv, ok := value.(json.Number) 16322 if !ok { 16323 return fmt.Errorf("expected PositiveInteger to be json.Number, got %T instead", value) 16324 } 16325 i64, err := jtv.Int64() 16326 if err != nil { 16327 return err 16328 } 16329 sv.RequestedProvisionedConcurrentExecutions = ptr.Int32(int32(i64)) 16330 } 16331 16332 case "Status": 16333 if value != nil { 16334 jtv, ok := value.(string) 16335 if !ok { 16336 return fmt.Errorf("expected ProvisionedConcurrencyStatusEnum to be of type string, got %T instead", value) 16337 } 16338 sv.Status = types.ProvisionedConcurrencyStatusEnum(jtv) 16339 } 16340 16341 case "StatusReason": 16342 if value != nil { 16343 jtv, ok := value.(string) 16344 if !ok { 16345 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16346 } 16347 sv.StatusReason = ptr.String(jtv) 16348 } 16349 16350 default: 16351 _, _ = key, value 16352 16353 } 16354 } 16355 *v = sv 16356 return nil 16357} 16358 16359func awsRestjson1_deserializeDocumentProvisionedConcurrencyConfigNotFoundException(v **types.ProvisionedConcurrencyConfigNotFoundException, value interface{}) error { 16360 if v == nil { 16361 return fmt.Errorf("unexpected nil of type %T", v) 16362 } 16363 if value == nil { 16364 return nil 16365 } 16366 16367 shape, ok := value.(map[string]interface{}) 16368 if !ok { 16369 return fmt.Errorf("unexpected JSON type %v", value) 16370 } 16371 16372 var sv *types.ProvisionedConcurrencyConfigNotFoundException 16373 if *v == nil { 16374 sv = &types.ProvisionedConcurrencyConfigNotFoundException{} 16375 } else { 16376 sv = *v 16377 } 16378 16379 for key, value := range shape { 16380 switch key { 16381 case "message": 16382 if value != nil { 16383 jtv, ok := value.(string) 16384 if !ok { 16385 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16386 } 16387 sv.Message = ptr.String(jtv) 16388 } 16389 16390 case "Type": 16391 if value != nil { 16392 jtv, ok := value.(string) 16393 if !ok { 16394 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16395 } 16396 sv.Type = ptr.String(jtv) 16397 } 16398 16399 default: 16400 _, _ = key, value 16401 16402 } 16403 } 16404 *v = sv 16405 return nil 16406} 16407 16408func awsRestjson1_deserializeDocumentQueues(v *[]string, value interface{}) error { 16409 if v == nil { 16410 return fmt.Errorf("unexpected nil of type %T", v) 16411 } 16412 if value == nil { 16413 return nil 16414 } 16415 16416 shape, ok := value.([]interface{}) 16417 if !ok { 16418 return fmt.Errorf("unexpected JSON type %v", value) 16419 } 16420 16421 var cv []string 16422 if *v == nil { 16423 cv = []string{} 16424 } else { 16425 cv = *v 16426 } 16427 16428 for _, value := range shape { 16429 var col string 16430 if value != nil { 16431 jtv, ok := value.(string) 16432 if !ok { 16433 return fmt.Errorf("expected Queue to be of type string, got %T instead", value) 16434 } 16435 col = jtv 16436 } 16437 cv = append(cv, col) 16438 16439 } 16440 *v = cv 16441 return nil 16442} 16443 16444func awsRestjson1_deserializeDocumentRequestTooLargeException(v **types.RequestTooLargeException, value interface{}) error { 16445 if v == nil { 16446 return fmt.Errorf("unexpected nil of type %T", v) 16447 } 16448 if value == nil { 16449 return nil 16450 } 16451 16452 shape, ok := value.(map[string]interface{}) 16453 if !ok { 16454 return fmt.Errorf("unexpected JSON type %v", value) 16455 } 16456 16457 var sv *types.RequestTooLargeException 16458 if *v == nil { 16459 sv = &types.RequestTooLargeException{} 16460 } else { 16461 sv = *v 16462 } 16463 16464 for key, value := range shape { 16465 switch key { 16466 case "message": 16467 if value != nil { 16468 jtv, ok := value.(string) 16469 if !ok { 16470 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16471 } 16472 sv.Message = ptr.String(jtv) 16473 } 16474 16475 case "Type": 16476 if value != nil { 16477 jtv, ok := value.(string) 16478 if !ok { 16479 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16480 } 16481 sv.Type = ptr.String(jtv) 16482 } 16483 16484 default: 16485 _, _ = key, value 16486 16487 } 16488 } 16489 *v = sv 16490 return nil 16491} 16492 16493func awsRestjson1_deserializeDocumentResourceConflictException(v **types.ResourceConflictException, value interface{}) error { 16494 if v == nil { 16495 return fmt.Errorf("unexpected nil of type %T", v) 16496 } 16497 if value == nil { 16498 return nil 16499 } 16500 16501 shape, ok := value.(map[string]interface{}) 16502 if !ok { 16503 return fmt.Errorf("unexpected JSON type %v", value) 16504 } 16505 16506 var sv *types.ResourceConflictException 16507 if *v == nil { 16508 sv = &types.ResourceConflictException{} 16509 } else { 16510 sv = *v 16511 } 16512 16513 for key, value := range shape { 16514 switch key { 16515 case "message": 16516 if value != nil { 16517 jtv, ok := value.(string) 16518 if !ok { 16519 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16520 } 16521 sv.Message = ptr.String(jtv) 16522 } 16523 16524 case "Type": 16525 if value != nil { 16526 jtv, ok := value.(string) 16527 if !ok { 16528 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16529 } 16530 sv.Type = ptr.String(jtv) 16531 } 16532 16533 default: 16534 _, _ = key, value 16535 16536 } 16537 } 16538 *v = sv 16539 return nil 16540} 16541 16542func awsRestjson1_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 16543 if v == nil { 16544 return fmt.Errorf("unexpected nil of type %T", v) 16545 } 16546 if value == nil { 16547 return nil 16548 } 16549 16550 shape, ok := value.(map[string]interface{}) 16551 if !ok { 16552 return fmt.Errorf("unexpected JSON type %v", value) 16553 } 16554 16555 var sv *types.ResourceInUseException 16556 if *v == nil { 16557 sv = &types.ResourceInUseException{} 16558 } else { 16559 sv = *v 16560 } 16561 16562 for key, value := range shape { 16563 switch key { 16564 case "Message": 16565 if value != nil { 16566 jtv, ok := value.(string) 16567 if !ok { 16568 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16569 } 16570 sv.Message = ptr.String(jtv) 16571 } 16572 16573 case "Type": 16574 if value != nil { 16575 jtv, ok := value.(string) 16576 if !ok { 16577 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16578 } 16579 sv.Type = ptr.String(jtv) 16580 } 16581 16582 default: 16583 _, _ = key, value 16584 16585 } 16586 } 16587 *v = sv 16588 return nil 16589} 16590 16591func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 16592 if v == nil { 16593 return fmt.Errorf("unexpected nil of type %T", v) 16594 } 16595 if value == nil { 16596 return nil 16597 } 16598 16599 shape, ok := value.(map[string]interface{}) 16600 if !ok { 16601 return fmt.Errorf("unexpected JSON type %v", value) 16602 } 16603 16604 var sv *types.ResourceNotFoundException 16605 if *v == nil { 16606 sv = &types.ResourceNotFoundException{} 16607 } else { 16608 sv = *v 16609 } 16610 16611 for key, value := range shape { 16612 switch key { 16613 case "Message": 16614 if value != nil { 16615 jtv, ok := value.(string) 16616 if !ok { 16617 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16618 } 16619 sv.Message = ptr.String(jtv) 16620 } 16621 16622 case "Type": 16623 if value != nil { 16624 jtv, ok := value.(string) 16625 if !ok { 16626 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16627 } 16628 sv.Type = ptr.String(jtv) 16629 } 16630 16631 default: 16632 _, _ = key, value 16633 16634 } 16635 } 16636 *v = sv 16637 return nil 16638} 16639 16640func awsRestjson1_deserializeDocumentResourceNotReadyException(v **types.ResourceNotReadyException, value interface{}) error { 16641 if v == nil { 16642 return fmt.Errorf("unexpected nil of type %T", v) 16643 } 16644 if value == nil { 16645 return nil 16646 } 16647 16648 shape, ok := value.(map[string]interface{}) 16649 if !ok { 16650 return fmt.Errorf("unexpected JSON type %v", value) 16651 } 16652 16653 var sv *types.ResourceNotReadyException 16654 if *v == nil { 16655 sv = &types.ResourceNotReadyException{} 16656 } else { 16657 sv = *v 16658 } 16659 16660 for key, value := range shape { 16661 switch key { 16662 case "message": 16663 if value != nil { 16664 jtv, ok := value.(string) 16665 if !ok { 16666 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16667 } 16668 sv.Message = ptr.String(jtv) 16669 } 16670 16671 case "Type": 16672 if value != nil { 16673 jtv, ok := value.(string) 16674 if !ok { 16675 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16676 } 16677 sv.Type = ptr.String(jtv) 16678 } 16679 16680 default: 16681 _, _ = key, value 16682 16683 } 16684 } 16685 *v = sv 16686 return nil 16687} 16688 16689func awsRestjson1_deserializeDocumentSecurityGroupIds(v *[]string, value interface{}) error { 16690 if v == nil { 16691 return fmt.Errorf("unexpected nil of type %T", v) 16692 } 16693 if value == nil { 16694 return nil 16695 } 16696 16697 shape, ok := value.([]interface{}) 16698 if !ok { 16699 return fmt.Errorf("unexpected JSON type %v", value) 16700 } 16701 16702 var cv []string 16703 if *v == nil { 16704 cv = []string{} 16705 } else { 16706 cv = *v 16707 } 16708 16709 for _, value := range shape { 16710 var col string 16711 if value != nil { 16712 jtv, ok := value.(string) 16713 if !ok { 16714 return fmt.Errorf("expected SecurityGroupId to be of type string, got %T instead", value) 16715 } 16716 col = jtv 16717 } 16718 cv = append(cv, col) 16719 16720 } 16721 *v = cv 16722 return nil 16723} 16724 16725func awsRestjson1_deserializeDocumentSelfManagedEventSource(v **types.SelfManagedEventSource, value interface{}) error { 16726 if v == nil { 16727 return fmt.Errorf("unexpected nil of type %T", v) 16728 } 16729 if value == nil { 16730 return nil 16731 } 16732 16733 shape, ok := value.(map[string]interface{}) 16734 if !ok { 16735 return fmt.Errorf("unexpected JSON type %v", value) 16736 } 16737 16738 var sv *types.SelfManagedEventSource 16739 if *v == nil { 16740 sv = &types.SelfManagedEventSource{} 16741 } else { 16742 sv = *v 16743 } 16744 16745 for key, value := range shape { 16746 switch key { 16747 case "Endpoints": 16748 if err := awsRestjson1_deserializeDocumentEndpoints(&sv.Endpoints, value); err != nil { 16749 return err 16750 } 16751 16752 default: 16753 _, _ = key, value 16754 16755 } 16756 } 16757 *v = sv 16758 return nil 16759} 16760 16761func awsRestjson1_deserializeDocumentServiceException(v **types.ServiceException, value interface{}) error { 16762 if v == nil { 16763 return fmt.Errorf("unexpected nil of type %T", v) 16764 } 16765 if value == nil { 16766 return nil 16767 } 16768 16769 shape, ok := value.(map[string]interface{}) 16770 if !ok { 16771 return fmt.Errorf("unexpected JSON type %v", value) 16772 } 16773 16774 var sv *types.ServiceException 16775 if *v == nil { 16776 sv = &types.ServiceException{} 16777 } else { 16778 sv = *v 16779 } 16780 16781 for key, value := range shape { 16782 switch key { 16783 case "Message": 16784 if value != nil { 16785 jtv, ok := value.(string) 16786 if !ok { 16787 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16788 } 16789 sv.Message = ptr.String(jtv) 16790 } 16791 16792 case "Type": 16793 if value != nil { 16794 jtv, ok := value.(string) 16795 if !ok { 16796 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16797 } 16798 sv.Type = ptr.String(jtv) 16799 } 16800 16801 default: 16802 _, _ = key, value 16803 16804 } 16805 } 16806 *v = sv 16807 return nil 16808} 16809 16810func awsRestjson1_deserializeDocumentSigningProfileVersionArns(v *[]string, value interface{}) error { 16811 if v == nil { 16812 return fmt.Errorf("unexpected nil of type %T", v) 16813 } 16814 if value == nil { 16815 return nil 16816 } 16817 16818 shape, ok := value.([]interface{}) 16819 if !ok { 16820 return fmt.Errorf("unexpected JSON type %v", value) 16821 } 16822 16823 var cv []string 16824 if *v == nil { 16825 cv = []string{} 16826 } else { 16827 cv = *v 16828 } 16829 16830 for _, value := range shape { 16831 var col string 16832 if value != nil { 16833 jtv, ok := value.(string) 16834 if !ok { 16835 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 16836 } 16837 col = jtv 16838 } 16839 cv = append(cv, col) 16840 16841 } 16842 *v = cv 16843 return nil 16844} 16845 16846func awsRestjson1_deserializeDocumentSourceAccessConfiguration(v **types.SourceAccessConfiguration, value interface{}) error { 16847 if v == nil { 16848 return fmt.Errorf("unexpected nil of type %T", v) 16849 } 16850 if value == nil { 16851 return nil 16852 } 16853 16854 shape, ok := value.(map[string]interface{}) 16855 if !ok { 16856 return fmt.Errorf("unexpected JSON type %v", value) 16857 } 16858 16859 var sv *types.SourceAccessConfiguration 16860 if *v == nil { 16861 sv = &types.SourceAccessConfiguration{} 16862 } else { 16863 sv = *v 16864 } 16865 16866 for key, value := range shape { 16867 switch key { 16868 case "Type": 16869 if value != nil { 16870 jtv, ok := value.(string) 16871 if !ok { 16872 return fmt.Errorf("expected SourceAccessType to be of type string, got %T instead", value) 16873 } 16874 sv.Type = types.SourceAccessType(jtv) 16875 } 16876 16877 case "URI": 16878 if value != nil { 16879 jtv, ok := value.(string) 16880 if !ok { 16881 return fmt.Errorf("expected URI to be of type string, got %T instead", value) 16882 } 16883 sv.URI = ptr.String(jtv) 16884 } 16885 16886 default: 16887 _, _ = key, value 16888 16889 } 16890 } 16891 *v = sv 16892 return nil 16893} 16894 16895func awsRestjson1_deserializeDocumentSourceAccessConfigurations(v *[]types.SourceAccessConfiguration, value interface{}) error { 16896 if v == nil { 16897 return fmt.Errorf("unexpected nil of type %T", v) 16898 } 16899 if value == nil { 16900 return nil 16901 } 16902 16903 shape, ok := value.([]interface{}) 16904 if !ok { 16905 return fmt.Errorf("unexpected JSON type %v", value) 16906 } 16907 16908 var cv []types.SourceAccessConfiguration 16909 if *v == nil { 16910 cv = []types.SourceAccessConfiguration{} 16911 } else { 16912 cv = *v 16913 } 16914 16915 for _, value := range shape { 16916 var col types.SourceAccessConfiguration 16917 destAddr := &col 16918 if err := awsRestjson1_deserializeDocumentSourceAccessConfiguration(&destAddr, value); err != nil { 16919 return err 16920 } 16921 col = *destAddr 16922 cv = append(cv, col) 16923 16924 } 16925 *v = cv 16926 return nil 16927} 16928 16929func awsRestjson1_deserializeDocumentStringList(v *[]string, value interface{}) error { 16930 if v == nil { 16931 return fmt.Errorf("unexpected nil of type %T", v) 16932 } 16933 if value == nil { 16934 return nil 16935 } 16936 16937 shape, ok := value.([]interface{}) 16938 if !ok { 16939 return fmt.Errorf("unexpected JSON type %v", value) 16940 } 16941 16942 var cv []string 16943 if *v == nil { 16944 cv = []string{} 16945 } else { 16946 cv = *v 16947 } 16948 16949 for _, value := range shape { 16950 var col string 16951 if value != nil { 16952 jtv, ok := value.(string) 16953 if !ok { 16954 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16955 } 16956 col = jtv 16957 } 16958 cv = append(cv, col) 16959 16960 } 16961 *v = cv 16962 return nil 16963} 16964 16965func awsRestjson1_deserializeDocumentSubnetIds(v *[]string, value interface{}) error { 16966 if v == nil { 16967 return fmt.Errorf("unexpected nil of type %T", v) 16968 } 16969 if value == nil { 16970 return nil 16971 } 16972 16973 shape, ok := value.([]interface{}) 16974 if !ok { 16975 return fmt.Errorf("unexpected JSON type %v", value) 16976 } 16977 16978 var cv []string 16979 if *v == nil { 16980 cv = []string{} 16981 } else { 16982 cv = *v 16983 } 16984 16985 for _, value := range shape { 16986 var col string 16987 if value != nil { 16988 jtv, ok := value.(string) 16989 if !ok { 16990 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 16991 } 16992 col = jtv 16993 } 16994 cv = append(cv, col) 16995 16996 } 16997 *v = cv 16998 return nil 16999} 17000 17001func awsRestjson1_deserializeDocumentSubnetIPAddressLimitReachedException(v **types.SubnetIPAddressLimitReachedException, value interface{}) error { 17002 if v == nil { 17003 return fmt.Errorf("unexpected nil of type %T", v) 17004 } 17005 if value == nil { 17006 return nil 17007 } 17008 17009 shape, ok := value.(map[string]interface{}) 17010 if !ok { 17011 return fmt.Errorf("unexpected JSON type %v", value) 17012 } 17013 17014 var sv *types.SubnetIPAddressLimitReachedException 17015 if *v == nil { 17016 sv = &types.SubnetIPAddressLimitReachedException{} 17017 } else { 17018 sv = *v 17019 } 17020 17021 for key, value := range shape { 17022 switch key { 17023 case "Message": 17024 if value != nil { 17025 jtv, ok := value.(string) 17026 if !ok { 17027 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17028 } 17029 sv.Message = ptr.String(jtv) 17030 } 17031 17032 case "Type": 17033 if value != nil { 17034 jtv, ok := value.(string) 17035 if !ok { 17036 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17037 } 17038 sv.Type = ptr.String(jtv) 17039 } 17040 17041 default: 17042 _, _ = key, value 17043 17044 } 17045 } 17046 *v = sv 17047 return nil 17048} 17049 17050func awsRestjson1_deserializeDocumentTags(v *map[string]string, value interface{}) error { 17051 if v == nil { 17052 return fmt.Errorf("unexpected nil of type %T", v) 17053 } 17054 if value == nil { 17055 return nil 17056 } 17057 17058 shape, ok := value.(map[string]interface{}) 17059 if !ok { 17060 return fmt.Errorf("unexpected JSON type %v", value) 17061 } 17062 17063 var mv map[string]string 17064 if *v == nil { 17065 mv = map[string]string{} 17066 } else { 17067 mv = *v 17068 } 17069 17070 for key, value := range shape { 17071 var parsedVal string 17072 if value != nil { 17073 jtv, ok := value.(string) 17074 if !ok { 17075 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 17076 } 17077 parsedVal = jtv 17078 } 17079 mv[key] = parsedVal 17080 17081 } 17082 *v = mv 17083 return nil 17084} 17085 17086func awsRestjson1_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error { 17087 if v == nil { 17088 return fmt.Errorf("unexpected nil of type %T", v) 17089 } 17090 if value == nil { 17091 return nil 17092 } 17093 17094 shape, ok := value.(map[string]interface{}) 17095 if !ok { 17096 return fmt.Errorf("unexpected JSON type %v", value) 17097 } 17098 17099 var sv *types.TooManyRequestsException 17100 if *v == nil { 17101 sv = &types.TooManyRequestsException{} 17102 } else { 17103 sv = *v 17104 } 17105 17106 for key, value := range shape { 17107 switch key { 17108 case "message": 17109 if value != nil { 17110 jtv, ok := value.(string) 17111 if !ok { 17112 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17113 } 17114 sv.Message = ptr.String(jtv) 17115 } 17116 17117 case "Reason": 17118 if value != nil { 17119 jtv, ok := value.(string) 17120 if !ok { 17121 return fmt.Errorf("expected ThrottleReason to be of type string, got %T instead", value) 17122 } 17123 sv.Reason = types.ThrottleReason(jtv) 17124 } 17125 17126 case "retryAfterSeconds": 17127 if value != nil { 17128 jtv, ok := value.(string) 17129 if !ok { 17130 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17131 } 17132 sv.RetryAfterSeconds = ptr.String(jtv) 17133 } 17134 17135 case "Type": 17136 if value != nil { 17137 jtv, ok := value.(string) 17138 if !ok { 17139 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17140 } 17141 sv.Type = ptr.String(jtv) 17142 } 17143 17144 default: 17145 _, _ = key, value 17146 17147 } 17148 } 17149 *v = sv 17150 return nil 17151} 17152 17153func awsRestjson1_deserializeDocumentTopics(v *[]string, value interface{}) error { 17154 if v == nil { 17155 return fmt.Errorf("unexpected nil of type %T", v) 17156 } 17157 if value == nil { 17158 return nil 17159 } 17160 17161 shape, ok := value.([]interface{}) 17162 if !ok { 17163 return fmt.Errorf("unexpected JSON type %v", value) 17164 } 17165 17166 var cv []string 17167 if *v == nil { 17168 cv = []string{} 17169 } else { 17170 cv = *v 17171 } 17172 17173 for _, value := range shape { 17174 var col string 17175 if value != nil { 17176 jtv, ok := value.(string) 17177 if !ok { 17178 return fmt.Errorf("expected Topic to be of type string, got %T instead", value) 17179 } 17180 col = jtv 17181 } 17182 cv = append(cv, col) 17183 17184 } 17185 *v = cv 17186 return nil 17187} 17188 17189func awsRestjson1_deserializeDocumentTracingConfigResponse(v **types.TracingConfigResponse, value interface{}) error { 17190 if v == nil { 17191 return fmt.Errorf("unexpected nil of type %T", v) 17192 } 17193 if value == nil { 17194 return nil 17195 } 17196 17197 shape, ok := value.(map[string]interface{}) 17198 if !ok { 17199 return fmt.Errorf("unexpected JSON type %v", value) 17200 } 17201 17202 var sv *types.TracingConfigResponse 17203 if *v == nil { 17204 sv = &types.TracingConfigResponse{} 17205 } else { 17206 sv = *v 17207 } 17208 17209 for key, value := range shape { 17210 switch key { 17211 case "Mode": 17212 if value != nil { 17213 jtv, ok := value.(string) 17214 if !ok { 17215 return fmt.Errorf("expected TracingMode to be of type string, got %T instead", value) 17216 } 17217 sv.Mode = types.TracingMode(jtv) 17218 } 17219 17220 default: 17221 _, _ = key, value 17222 17223 } 17224 } 17225 *v = sv 17226 return nil 17227} 17228 17229func awsRestjson1_deserializeDocumentUnsupportedMediaTypeException(v **types.UnsupportedMediaTypeException, value interface{}) error { 17230 if v == nil { 17231 return fmt.Errorf("unexpected nil of type %T", v) 17232 } 17233 if value == nil { 17234 return nil 17235 } 17236 17237 shape, ok := value.(map[string]interface{}) 17238 if !ok { 17239 return fmt.Errorf("unexpected JSON type %v", value) 17240 } 17241 17242 var sv *types.UnsupportedMediaTypeException 17243 if *v == nil { 17244 sv = &types.UnsupportedMediaTypeException{} 17245 } else { 17246 sv = *v 17247 } 17248 17249 for key, value := range shape { 17250 switch key { 17251 case "message": 17252 if value != nil { 17253 jtv, ok := value.(string) 17254 if !ok { 17255 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17256 } 17257 sv.Message = ptr.String(jtv) 17258 } 17259 17260 case "Type": 17261 if value != nil { 17262 jtv, ok := value.(string) 17263 if !ok { 17264 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17265 } 17266 sv.Type = ptr.String(jtv) 17267 } 17268 17269 default: 17270 _, _ = key, value 17271 17272 } 17273 } 17274 *v = sv 17275 return nil 17276} 17277 17278func awsRestjson1_deserializeDocumentVpcConfigResponse(v **types.VpcConfigResponse, value interface{}) error { 17279 if v == nil { 17280 return fmt.Errorf("unexpected nil of type %T", v) 17281 } 17282 if value == nil { 17283 return nil 17284 } 17285 17286 shape, ok := value.(map[string]interface{}) 17287 if !ok { 17288 return fmt.Errorf("unexpected JSON type %v", value) 17289 } 17290 17291 var sv *types.VpcConfigResponse 17292 if *v == nil { 17293 sv = &types.VpcConfigResponse{} 17294 } else { 17295 sv = *v 17296 } 17297 17298 for key, value := range shape { 17299 switch key { 17300 case "SecurityGroupIds": 17301 if err := awsRestjson1_deserializeDocumentSecurityGroupIds(&sv.SecurityGroupIds, value); err != nil { 17302 return err 17303 } 17304 17305 case "SubnetIds": 17306 if err := awsRestjson1_deserializeDocumentSubnetIds(&sv.SubnetIds, value); err != nil { 17307 return err 17308 } 17309 17310 case "VpcId": 17311 if value != nil { 17312 jtv, ok := value.(string) 17313 if !ok { 17314 return fmt.Errorf("expected VpcId to be of type string, got %T instead", value) 17315 } 17316 sv.VpcId = ptr.String(jtv) 17317 } 17318 17319 default: 17320 _, _ = key, value 17321 17322 } 17323 } 17324 *v = sv 17325 return nil 17326} 17327