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