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