1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package forecast 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/forecast/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "io/ioutil" 20 "strings" 21) 22 23type awsAwsjson11_deserializeOpCreateDataset struct { 24} 25 26func (*awsAwsjson11_deserializeOpCreateDataset) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson11_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, awsAwsjson11_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 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsAwsjson11_deserializeOpDocumentCreateDatasetOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 err = &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 return out, metadata, err 75 } 76 77 return out, metadata, err 78} 79 80func awsAwsjson11_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("InvalidInputException", errorCode): 122 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 123 124 case strings.EqualFold("LimitExceededException", errorCode): 125 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 126 127 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 128 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 129 130 default: 131 genericError := &smithy.GenericAPIError{ 132 Code: errorCode, 133 Message: errorMessage, 134 } 135 return genericError 136 137 } 138} 139 140type awsAwsjson11_deserializeOpCreateDatasetGroup struct { 141} 142 143func (*awsAwsjson11_deserializeOpCreateDatasetGroup) ID() string { 144 return "OperationDeserializer" 145} 146 147func (m *awsAwsjson11_deserializeOpCreateDatasetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 148 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 149) { 150 out, metadata, err = next.HandleDeserialize(ctx, in) 151 if err != nil { 152 return out, metadata, err 153 } 154 155 response, ok := out.RawResponse.(*smithyhttp.Response) 156 if !ok { 157 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 158 } 159 160 if response.StatusCode < 200 || response.StatusCode >= 300 { 161 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDatasetGroup(response, &metadata) 162 } 163 output := &CreateDatasetGroupOutput{} 164 out.Result = output 165 166 var buff [1024]byte 167 ringBuffer := smithyio.NewRingBuffer(buff[:]) 168 169 body := io.TeeReader(response.Body, ringBuffer) 170 decoder := json.NewDecoder(body) 171 decoder.UseNumber() 172 var shape interface{} 173 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 174 var snapshot bytes.Buffer 175 io.Copy(&snapshot, ringBuffer) 176 err = &smithy.DeserializationError{ 177 Err: fmt.Errorf("failed to decode response body, %w", err), 178 Snapshot: snapshot.Bytes(), 179 } 180 return out, metadata, err 181 } 182 183 err = awsAwsjson11_deserializeOpDocumentCreateDatasetGroupOutput(&output, shape) 184 if err != nil { 185 var snapshot bytes.Buffer 186 io.Copy(&snapshot, ringBuffer) 187 err = &smithy.DeserializationError{ 188 Err: fmt.Errorf("failed to decode response body, %w", err), 189 Snapshot: snapshot.Bytes(), 190 } 191 return out, metadata, err 192 } 193 194 return out, metadata, err 195} 196 197func awsAwsjson11_deserializeOpErrorCreateDatasetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 198 var errorBuffer bytes.Buffer 199 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 200 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 201 } 202 errorBody := bytes.NewReader(errorBuffer.Bytes()) 203 204 errorCode := "UnknownError" 205 errorMessage := errorCode 206 207 code := response.Header.Get("X-Amzn-ErrorType") 208 if len(code) != 0 { 209 errorCode = restjson.SanitizeErrorCode(code) 210 } 211 212 var buff [1024]byte 213 ringBuffer := smithyio.NewRingBuffer(buff[:]) 214 215 body := io.TeeReader(errorBody, ringBuffer) 216 decoder := json.NewDecoder(body) 217 decoder.UseNumber() 218 code, message, err := restjson.GetErrorInfo(decoder) 219 if err != nil { 220 var snapshot bytes.Buffer 221 io.Copy(&snapshot, ringBuffer) 222 err = &smithy.DeserializationError{ 223 Err: fmt.Errorf("failed to decode response body, %w", err), 224 Snapshot: snapshot.Bytes(), 225 } 226 return err 227 } 228 229 errorBody.Seek(0, io.SeekStart) 230 if len(code) != 0 { 231 errorCode = restjson.SanitizeErrorCode(code) 232 } 233 if len(message) != 0 { 234 errorMessage = message 235 } 236 237 switch { 238 case strings.EqualFold("InvalidInputException", errorCode): 239 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 240 241 case strings.EqualFold("LimitExceededException", errorCode): 242 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 243 244 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 245 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 246 247 case strings.EqualFold("ResourceInUseException", errorCode): 248 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 249 250 case strings.EqualFold("ResourceNotFoundException", errorCode): 251 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 252 253 default: 254 genericError := &smithy.GenericAPIError{ 255 Code: errorCode, 256 Message: errorMessage, 257 } 258 return genericError 259 260 } 261} 262 263type awsAwsjson11_deserializeOpCreateDatasetImportJob struct { 264} 265 266func (*awsAwsjson11_deserializeOpCreateDatasetImportJob) ID() string { 267 return "OperationDeserializer" 268} 269 270func (m *awsAwsjson11_deserializeOpCreateDatasetImportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 271 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 272) { 273 out, metadata, err = next.HandleDeserialize(ctx, in) 274 if err != nil { 275 return out, metadata, err 276 } 277 278 response, ok := out.RawResponse.(*smithyhttp.Response) 279 if !ok { 280 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 281 } 282 283 if response.StatusCode < 200 || response.StatusCode >= 300 { 284 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDatasetImportJob(response, &metadata) 285 } 286 output := &CreateDatasetImportJobOutput{} 287 out.Result = output 288 289 var buff [1024]byte 290 ringBuffer := smithyio.NewRingBuffer(buff[:]) 291 292 body := io.TeeReader(response.Body, ringBuffer) 293 decoder := json.NewDecoder(body) 294 decoder.UseNumber() 295 var shape interface{} 296 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 297 var snapshot bytes.Buffer 298 io.Copy(&snapshot, ringBuffer) 299 err = &smithy.DeserializationError{ 300 Err: fmt.Errorf("failed to decode response body, %w", err), 301 Snapshot: snapshot.Bytes(), 302 } 303 return out, metadata, err 304 } 305 306 err = awsAwsjson11_deserializeOpDocumentCreateDatasetImportJobOutput(&output, shape) 307 if err != nil { 308 var snapshot bytes.Buffer 309 io.Copy(&snapshot, ringBuffer) 310 err = &smithy.DeserializationError{ 311 Err: fmt.Errorf("failed to decode response body, %w", err), 312 Snapshot: snapshot.Bytes(), 313 } 314 return out, metadata, err 315 } 316 317 return out, metadata, err 318} 319 320func awsAwsjson11_deserializeOpErrorCreateDatasetImportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 321 var errorBuffer bytes.Buffer 322 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 323 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 324 } 325 errorBody := bytes.NewReader(errorBuffer.Bytes()) 326 327 errorCode := "UnknownError" 328 errorMessage := errorCode 329 330 code := response.Header.Get("X-Amzn-ErrorType") 331 if len(code) != 0 { 332 errorCode = restjson.SanitizeErrorCode(code) 333 } 334 335 var buff [1024]byte 336 ringBuffer := smithyio.NewRingBuffer(buff[:]) 337 338 body := io.TeeReader(errorBody, ringBuffer) 339 decoder := json.NewDecoder(body) 340 decoder.UseNumber() 341 code, message, err := restjson.GetErrorInfo(decoder) 342 if err != nil { 343 var snapshot bytes.Buffer 344 io.Copy(&snapshot, ringBuffer) 345 err = &smithy.DeserializationError{ 346 Err: fmt.Errorf("failed to decode response body, %w", err), 347 Snapshot: snapshot.Bytes(), 348 } 349 return err 350 } 351 352 errorBody.Seek(0, io.SeekStart) 353 if len(code) != 0 { 354 errorCode = restjson.SanitizeErrorCode(code) 355 } 356 if len(message) != 0 { 357 errorMessage = message 358 } 359 360 switch { 361 case strings.EqualFold("InvalidInputException", errorCode): 362 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 363 364 case strings.EqualFold("LimitExceededException", errorCode): 365 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 366 367 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 368 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 369 370 case strings.EqualFold("ResourceInUseException", errorCode): 371 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 372 373 case strings.EqualFold("ResourceNotFoundException", errorCode): 374 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 375 376 default: 377 genericError := &smithy.GenericAPIError{ 378 Code: errorCode, 379 Message: errorMessage, 380 } 381 return genericError 382 383 } 384} 385 386type awsAwsjson11_deserializeOpCreateForecast struct { 387} 388 389func (*awsAwsjson11_deserializeOpCreateForecast) ID() string { 390 return "OperationDeserializer" 391} 392 393func (m *awsAwsjson11_deserializeOpCreateForecast) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 394 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 395) { 396 out, metadata, err = next.HandleDeserialize(ctx, in) 397 if err != nil { 398 return out, metadata, err 399 } 400 401 response, ok := out.RawResponse.(*smithyhttp.Response) 402 if !ok { 403 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 404 } 405 406 if response.StatusCode < 200 || response.StatusCode >= 300 { 407 return out, metadata, awsAwsjson11_deserializeOpErrorCreateForecast(response, &metadata) 408 } 409 output := &CreateForecastOutput{} 410 out.Result = output 411 412 var buff [1024]byte 413 ringBuffer := smithyio.NewRingBuffer(buff[:]) 414 415 body := io.TeeReader(response.Body, ringBuffer) 416 decoder := json.NewDecoder(body) 417 decoder.UseNumber() 418 var shape interface{} 419 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 420 var snapshot bytes.Buffer 421 io.Copy(&snapshot, ringBuffer) 422 err = &smithy.DeserializationError{ 423 Err: fmt.Errorf("failed to decode response body, %w", err), 424 Snapshot: snapshot.Bytes(), 425 } 426 return out, metadata, err 427 } 428 429 err = awsAwsjson11_deserializeOpDocumentCreateForecastOutput(&output, shape) 430 if err != nil { 431 var snapshot bytes.Buffer 432 io.Copy(&snapshot, ringBuffer) 433 err = &smithy.DeserializationError{ 434 Err: fmt.Errorf("failed to decode response body, %w", err), 435 Snapshot: snapshot.Bytes(), 436 } 437 return out, metadata, err 438 } 439 440 return out, metadata, err 441} 442 443func awsAwsjson11_deserializeOpErrorCreateForecast(response *smithyhttp.Response, metadata *middleware.Metadata) error { 444 var errorBuffer bytes.Buffer 445 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 446 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 447 } 448 errorBody := bytes.NewReader(errorBuffer.Bytes()) 449 450 errorCode := "UnknownError" 451 errorMessage := errorCode 452 453 code := response.Header.Get("X-Amzn-ErrorType") 454 if len(code) != 0 { 455 errorCode = restjson.SanitizeErrorCode(code) 456 } 457 458 var buff [1024]byte 459 ringBuffer := smithyio.NewRingBuffer(buff[:]) 460 461 body := io.TeeReader(errorBody, ringBuffer) 462 decoder := json.NewDecoder(body) 463 decoder.UseNumber() 464 code, message, err := restjson.GetErrorInfo(decoder) 465 if err != nil { 466 var snapshot bytes.Buffer 467 io.Copy(&snapshot, ringBuffer) 468 err = &smithy.DeserializationError{ 469 Err: fmt.Errorf("failed to decode response body, %w", err), 470 Snapshot: snapshot.Bytes(), 471 } 472 return err 473 } 474 475 errorBody.Seek(0, io.SeekStart) 476 if len(code) != 0 { 477 errorCode = restjson.SanitizeErrorCode(code) 478 } 479 if len(message) != 0 { 480 errorMessage = message 481 } 482 483 switch { 484 case strings.EqualFold("InvalidInputException", errorCode): 485 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 486 487 case strings.EqualFold("LimitExceededException", errorCode): 488 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 489 490 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 491 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 492 493 case strings.EqualFold("ResourceInUseException", errorCode): 494 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 495 496 case strings.EqualFold("ResourceNotFoundException", errorCode): 497 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 498 499 default: 500 genericError := &smithy.GenericAPIError{ 501 Code: errorCode, 502 Message: errorMessage, 503 } 504 return genericError 505 506 } 507} 508 509type awsAwsjson11_deserializeOpCreateForecastExportJob struct { 510} 511 512func (*awsAwsjson11_deserializeOpCreateForecastExportJob) ID() string { 513 return "OperationDeserializer" 514} 515 516func (m *awsAwsjson11_deserializeOpCreateForecastExportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 517 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 518) { 519 out, metadata, err = next.HandleDeserialize(ctx, in) 520 if err != nil { 521 return out, metadata, err 522 } 523 524 response, ok := out.RawResponse.(*smithyhttp.Response) 525 if !ok { 526 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 527 } 528 529 if response.StatusCode < 200 || response.StatusCode >= 300 { 530 return out, metadata, awsAwsjson11_deserializeOpErrorCreateForecastExportJob(response, &metadata) 531 } 532 output := &CreateForecastExportJobOutput{} 533 out.Result = output 534 535 var buff [1024]byte 536 ringBuffer := smithyio.NewRingBuffer(buff[:]) 537 538 body := io.TeeReader(response.Body, ringBuffer) 539 decoder := json.NewDecoder(body) 540 decoder.UseNumber() 541 var shape interface{} 542 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 543 var snapshot bytes.Buffer 544 io.Copy(&snapshot, ringBuffer) 545 err = &smithy.DeserializationError{ 546 Err: fmt.Errorf("failed to decode response body, %w", err), 547 Snapshot: snapshot.Bytes(), 548 } 549 return out, metadata, err 550 } 551 552 err = awsAwsjson11_deserializeOpDocumentCreateForecastExportJobOutput(&output, shape) 553 if err != nil { 554 var snapshot bytes.Buffer 555 io.Copy(&snapshot, ringBuffer) 556 err = &smithy.DeserializationError{ 557 Err: fmt.Errorf("failed to decode response body, %w", err), 558 Snapshot: snapshot.Bytes(), 559 } 560 return out, metadata, err 561 } 562 563 return out, metadata, err 564} 565 566func awsAwsjson11_deserializeOpErrorCreateForecastExportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 567 var errorBuffer bytes.Buffer 568 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 569 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 570 } 571 errorBody := bytes.NewReader(errorBuffer.Bytes()) 572 573 errorCode := "UnknownError" 574 errorMessage := errorCode 575 576 code := response.Header.Get("X-Amzn-ErrorType") 577 if len(code) != 0 { 578 errorCode = restjson.SanitizeErrorCode(code) 579 } 580 581 var buff [1024]byte 582 ringBuffer := smithyio.NewRingBuffer(buff[:]) 583 584 body := io.TeeReader(errorBody, ringBuffer) 585 decoder := json.NewDecoder(body) 586 decoder.UseNumber() 587 code, message, err := restjson.GetErrorInfo(decoder) 588 if err != nil { 589 var snapshot bytes.Buffer 590 io.Copy(&snapshot, ringBuffer) 591 err = &smithy.DeserializationError{ 592 Err: fmt.Errorf("failed to decode response body, %w", err), 593 Snapshot: snapshot.Bytes(), 594 } 595 return err 596 } 597 598 errorBody.Seek(0, io.SeekStart) 599 if len(code) != 0 { 600 errorCode = restjson.SanitizeErrorCode(code) 601 } 602 if len(message) != 0 { 603 errorMessage = message 604 } 605 606 switch { 607 case strings.EqualFold("InvalidInputException", errorCode): 608 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 609 610 case strings.EqualFold("LimitExceededException", errorCode): 611 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 612 613 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 614 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 615 616 case strings.EqualFold("ResourceInUseException", errorCode): 617 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 618 619 case strings.EqualFold("ResourceNotFoundException", errorCode): 620 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 621 622 default: 623 genericError := &smithy.GenericAPIError{ 624 Code: errorCode, 625 Message: errorMessage, 626 } 627 return genericError 628 629 } 630} 631 632type awsAwsjson11_deserializeOpCreatePredictor struct { 633} 634 635func (*awsAwsjson11_deserializeOpCreatePredictor) ID() string { 636 return "OperationDeserializer" 637} 638 639func (m *awsAwsjson11_deserializeOpCreatePredictor) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 640 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 641) { 642 out, metadata, err = next.HandleDeserialize(ctx, in) 643 if err != nil { 644 return out, metadata, err 645 } 646 647 response, ok := out.RawResponse.(*smithyhttp.Response) 648 if !ok { 649 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 650 } 651 652 if response.StatusCode < 200 || response.StatusCode >= 300 { 653 return out, metadata, awsAwsjson11_deserializeOpErrorCreatePredictor(response, &metadata) 654 } 655 output := &CreatePredictorOutput{} 656 out.Result = output 657 658 var buff [1024]byte 659 ringBuffer := smithyio.NewRingBuffer(buff[:]) 660 661 body := io.TeeReader(response.Body, ringBuffer) 662 decoder := json.NewDecoder(body) 663 decoder.UseNumber() 664 var shape interface{} 665 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 666 var snapshot bytes.Buffer 667 io.Copy(&snapshot, ringBuffer) 668 err = &smithy.DeserializationError{ 669 Err: fmt.Errorf("failed to decode response body, %w", err), 670 Snapshot: snapshot.Bytes(), 671 } 672 return out, metadata, err 673 } 674 675 err = awsAwsjson11_deserializeOpDocumentCreatePredictorOutput(&output, shape) 676 if err != nil { 677 var snapshot bytes.Buffer 678 io.Copy(&snapshot, ringBuffer) 679 err = &smithy.DeserializationError{ 680 Err: fmt.Errorf("failed to decode response body, %w", err), 681 Snapshot: snapshot.Bytes(), 682 } 683 return out, metadata, err 684 } 685 686 return out, metadata, err 687} 688 689func awsAwsjson11_deserializeOpErrorCreatePredictor(response *smithyhttp.Response, metadata *middleware.Metadata) error { 690 var errorBuffer bytes.Buffer 691 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 692 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 693 } 694 errorBody := bytes.NewReader(errorBuffer.Bytes()) 695 696 errorCode := "UnknownError" 697 errorMessage := errorCode 698 699 code := response.Header.Get("X-Amzn-ErrorType") 700 if len(code) != 0 { 701 errorCode = restjson.SanitizeErrorCode(code) 702 } 703 704 var buff [1024]byte 705 ringBuffer := smithyio.NewRingBuffer(buff[:]) 706 707 body := io.TeeReader(errorBody, ringBuffer) 708 decoder := json.NewDecoder(body) 709 decoder.UseNumber() 710 code, message, err := restjson.GetErrorInfo(decoder) 711 if err != nil { 712 var snapshot bytes.Buffer 713 io.Copy(&snapshot, ringBuffer) 714 err = &smithy.DeserializationError{ 715 Err: fmt.Errorf("failed to decode response body, %w", err), 716 Snapshot: snapshot.Bytes(), 717 } 718 return err 719 } 720 721 errorBody.Seek(0, io.SeekStart) 722 if len(code) != 0 { 723 errorCode = restjson.SanitizeErrorCode(code) 724 } 725 if len(message) != 0 { 726 errorMessage = message 727 } 728 729 switch { 730 case strings.EqualFold("InvalidInputException", errorCode): 731 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 732 733 case strings.EqualFold("LimitExceededException", errorCode): 734 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 735 736 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 737 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 738 739 case strings.EqualFold("ResourceInUseException", errorCode): 740 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 741 742 case strings.EqualFold("ResourceNotFoundException", errorCode): 743 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 744 745 default: 746 genericError := &smithy.GenericAPIError{ 747 Code: errorCode, 748 Message: errorMessage, 749 } 750 return genericError 751 752 } 753} 754 755type awsAwsjson11_deserializeOpCreatePredictorBacktestExportJob struct { 756} 757 758func (*awsAwsjson11_deserializeOpCreatePredictorBacktestExportJob) ID() string { 759 return "OperationDeserializer" 760} 761 762func (m *awsAwsjson11_deserializeOpCreatePredictorBacktestExportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 763 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 764) { 765 out, metadata, err = next.HandleDeserialize(ctx, in) 766 if err != nil { 767 return out, metadata, err 768 } 769 770 response, ok := out.RawResponse.(*smithyhttp.Response) 771 if !ok { 772 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 773 } 774 775 if response.StatusCode < 200 || response.StatusCode >= 300 { 776 return out, metadata, awsAwsjson11_deserializeOpErrorCreatePredictorBacktestExportJob(response, &metadata) 777 } 778 output := &CreatePredictorBacktestExportJobOutput{} 779 out.Result = output 780 781 var buff [1024]byte 782 ringBuffer := smithyio.NewRingBuffer(buff[:]) 783 784 body := io.TeeReader(response.Body, ringBuffer) 785 decoder := json.NewDecoder(body) 786 decoder.UseNumber() 787 var shape interface{} 788 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 789 var snapshot bytes.Buffer 790 io.Copy(&snapshot, ringBuffer) 791 err = &smithy.DeserializationError{ 792 Err: fmt.Errorf("failed to decode response body, %w", err), 793 Snapshot: snapshot.Bytes(), 794 } 795 return out, metadata, err 796 } 797 798 err = awsAwsjson11_deserializeOpDocumentCreatePredictorBacktestExportJobOutput(&output, shape) 799 if err != nil { 800 var snapshot bytes.Buffer 801 io.Copy(&snapshot, ringBuffer) 802 err = &smithy.DeserializationError{ 803 Err: fmt.Errorf("failed to decode response body, %w", err), 804 Snapshot: snapshot.Bytes(), 805 } 806 return out, metadata, err 807 } 808 809 return out, metadata, err 810} 811 812func awsAwsjson11_deserializeOpErrorCreatePredictorBacktestExportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 813 var errorBuffer bytes.Buffer 814 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 815 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 816 } 817 errorBody := bytes.NewReader(errorBuffer.Bytes()) 818 819 errorCode := "UnknownError" 820 errorMessage := errorCode 821 822 code := response.Header.Get("X-Amzn-ErrorType") 823 if len(code) != 0 { 824 errorCode = restjson.SanitizeErrorCode(code) 825 } 826 827 var buff [1024]byte 828 ringBuffer := smithyio.NewRingBuffer(buff[:]) 829 830 body := io.TeeReader(errorBody, ringBuffer) 831 decoder := json.NewDecoder(body) 832 decoder.UseNumber() 833 code, message, err := restjson.GetErrorInfo(decoder) 834 if err != nil { 835 var snapshot bytes.Buffer 836 io.Copy(&snapshot, ringBuffer) 837 err = &smithy.DeserializationError{ 838 Err: fmt.Errorf("failed to decode response body, %w", err), 839 Snapshot: snapshot.Bytes(), 840 } 841 return err 842 } 843 844 errorBody.Seek(0, io.SeekStart) 845 if len(code) != 0 { 846 errorCode = restjson.SanitizeErrorCode(code) 847 } 848 if len(message) != 0 { 849 errorMessage = message 850 } 851 852 switch { 853 case strings.EqualFold("InvalidInputException", errorCode): 854 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 855 856 case strings.EqualFold("LimitExceededException", errorCode): 857 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 858 859 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 860 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 861 862 case strings.EqualFold("ResourceInUseException", errorCode): 863 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 864 865 case strings.EqualFold("ResourceNotFoundException", errorCode): 866 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 867 868 default: 869 genericError := &smithy.GenericAPIError{ 870 Code: errorCode, 871 Message: errorMessage, 872 } 873 return genericError 874 875 } 876} 877 878type awsAwsjson11_deserializeOpDeleteDataset struct { 879} 880 881func (*awsAwsjson11_deserializeOpDeleteDataset) ID() string { 882 return "OperationDeserializer" 883} 884 885func (m *awsAwsjson11_deserializeOpDeleteDataset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 886 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 887) { 888 out, metadata, err = next.HandleDeserialize(ctx, in) 889 if err != nil { 890 return out, metadata, err 891 } 892 893 response, ok := out.RawResponse.(*smithyhttp.Response) 894 if !ok { 895 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 896 } 897 898 if response.StatusCode < 200 || response.StatusCode >= 300 { 899 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDataset(response, &metadata) 900 } 901 output := &DeleteDatasetOutput{} 902 out.Result = output 903 904 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 905 return out, metadata, &smithy.DeserializationError{ 906 Err: fmt.Errorf("failed to discard response body, %w", err), 907 } 908 } 909 910 return out, metadata, err 911} 912 913func awsAwsjson11_deserializeOpErrorDeleteDataset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 914 var errorBuffer bytes.Buffer 915 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 916 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 917 } 918 errorBody := bytes.NewReader(errorBuffer.Bytes()) 919 920 errorCode := "UnknownError" 921 errorMessage := errorCode 922 923 code := response.Header.Get("X-Amzn-ErrorType") 924 if len(code) != 0 { 925 errorCode = restjson.SanitizeErrorCode(code) 926 } 927 928 var buff [1024]byte 929 ringBuffer := smithyio.NewRingBuffer(buff[:]) 930 931 body := io.TeeReader(errorBody, ringBuffer) 932 decoder := json.NewDecoder(body) 933 decoder.UseNumber() 934 code, message, err := restjson.GetErrorInfo(decoder) 935 if err != nil { 936 var snapshot bytes.Buffer 937 io.Copy(&snapshot, ringBuffer) 938 err = &smithy.DeserializationError{ 939 Err: fmt.Errorf("failed to decode response body, %w", err), 940 Snapshot: snapshot.Bytes(), 941 } 942 return err 943 } 944 945 errorBody.Seek(0, io.SeekStart) 946 if len(code) != 0 { 947 errorCode = restjson.SanitizeErrorCode(code) 948 } 949 if len(message) != 0 { 950 errorMessage = message 951 } 952 953 switch { 954 case strings.EqualFold("InvalidInputException", errorCode): 955 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 956 957 case strings.EqualFold("ResourceInUseException", errorCode): 958 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 959 960 case strings.EqualFold("ResourceNotFoundException", errorCode): 961 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 962 963 default: 964 genericError := &smithy.GenericAPIError{ 965 Code: errorCode, 966 Message: errorMessage, 967 } 968 return genericError 969 970 } 971} 972 973type awsAwsjson11_deserializeOpDeleteDatasetGroup struct { 974} 975 976func (*awsAwsjson11_deserializeOpDeleteDatasetGroup) ID() string { 977 return "OperationDeserializer" 978} 979 980func (m *awsAwsjson11_deserializeOpDeleteDatasetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 981 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 982) { 983 out, metadata, err = next.HandleDeserialize(ctx, in) 984 if err != nil { 985 return out, metadata, err 986 } 987 988 response, ok := out.RawResponse.(*smithyhttp.Response) 989 if !ok { 990 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 991 } 992 993 if response.StatusCode < 200 || response.StatusCode >= 300 { 994 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDatasetGroup(response, &metadata) 995 } 996 output := &DeleteDatasetGroupOutput{} 997 out.Result = output 998 999 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1000 return out, metadata, &smithy.DeserializationError{ 1001 Err: fmt.Errorf("failed to discard response body, %w", err), 1002 } 1003 } 1004 1005 return out, metadata, err 1006} 1007 1008func awsAwsjson11_deserializeOpErrorDeleteDatasetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1009 var errorBuffer bytes.Buffer 1010 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1011 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1012 } 1013 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1014 1015 errorCode := "UnknownError" 1016 errorMessage := errorCode 1017 1018 code := response.Header.Get("X-Amzn-ErrorType") 1019 if len(code) != 0 { 1020 errorCode = restjson.SanitizeErrorCode(code) 1021 } 1022 1023 var buff [1024]byte 1024 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1025 1026 body := io.TeeReader(errorBody, ringBuffer) 1027 decoder := json.NewDecoder(body) 1028 decoder.UseNumber() 1029 code, message, err := restjson.GetErrorInfo(decoder) 1030 if err != nil { 1031 var snapshot bytes.Buffer 1032 io.Copy(&snapshot, ringBuffer) 1033 err = &smithy.DeserializationError{ 1034 Err: fmt.Errorf("failed to decode response body, %w", err), 1035 Snapshot: snapshot.Bytes(), 1036 } 1037 return err 1038 } 1039 1040 errorBody.Seek(0, io.SeekStart) 1041 if len(code) != 0 { 1042 errorCode = restjson.SanitizeErrorCode(code) 1043 } 1044 if len(message) != 0 { 1045 errorMessage = message 1046 } 1047 1048 switch { 1049 case strings.EqualFold("InvalidInputException", errorCode): 1050 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1051 1052 case strings.EqualFold("ResourceInUseException", errorCode): 1053 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1054 1055 case strings.EqualFold("ResourceNotFoundException", errorCode): 1056 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1057 1058 default: 1059 genericError := &smithy.GenericAPIError{ 1060 Code: errorCode, 1061 Message: errorMessage, 1062 } 1063 return genericError 1064 1065 } 1066} 1067 1068type awsAwsjson11_deserializeOpDeleteDatasetImportJob struct { 1069} 1070 1071func (*awsAwsjson11_deserializeOpDeleteDatasetImportJob) ID() string { 1072 return "OperationDeserializer" 1073} 1074 1075func (m *awsAwsjson11_deserializeOpDeleteDatasetImportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1076 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1077) { 1078 out, metadata, err = next.HandleDeserialize(ctx, in) 1079 if err != nil { 1080 return out, metadata, err 1081 } 1082 1083 response, ok := out.RawResponse.(*smithyhttp.Response) 1084 if !ok { 1085 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1086 } 1087 1088 if response.StatusCode < 200 || response.StatusCode >= 300 { 1089 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDatasetImportJob(response, &metadata) 1090 } 1091 output := &DeleteDatasetImportJobOutput{} 1092 out.Result = output 1093 1094 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1095 return out, metadata, &smithy.DeserializationError{ 1096 Err: fmt.Errorf("failed to discard response body, %w", err), 1097 } 1098 } 1099 1100 return out, metadata, err 1101} 1102 1103func awsAwsjson11_deserializeOpErrorDeleteDatasetImportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1104 var errorBuffer bytes.Buffer 1105 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1106 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1107 } 1108 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1109 1110 errorCode := "UnknownError" 1111 errorMessage := errorCode 1112 1113 code := response.Header.Get("X-Amzn-ErrorType") 1114 if len(code) != 0 { 1115 errorCode = restjson.SanitizeErrorCode(code) 1116 } 1117 1118 var buff [1024]byte 1119 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1120 1121 body := io.TeeReader(errorBody, ringBuffer) 1122 decoder := json.NewDecoder(body) 1123 decoder.UseNumber() 1124 code, message, err := restjson.GetErrorInfo(decoder) 1125 if err != nil { 1126 var snapshot bytes.Buffer 1127 io.Copy(&snapshot, ringBuffer) 1128 err = &smithy.DeserializationError{ 1129 Err: fmt.Errorf("failed to decode response body, %w", err), 1130 Snapshot: snapshot.Bytes(), 1131 } 1132 return err 1133 } 1134 1135 errorBody.Seek(0, io.SeekStart) 1136 if len(code) != 0 { 1137 errorCode = restjson.SanitizeErrorCode(code) 1138 } 1139 if len(message) != 0 { 1140 errorMessage = message 1141 } 1142 1143 switch { 1144 case strings.EqualFold("InvalidInputException", errorCode): 1145 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1146 1147 case strings.EqualFold("ResourceInUseException", errorCode): 1148 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1149 1150 case strings.EqualFold("ResourceNotFoundException", errorCode): 1151 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1152 1153 default: 1154 genericError := &smithy.GenericAPIError{ 1155 Code: errorCode, 1156 Message: errorMessage, 1157 } 1158 return genericError 1159 1160 } 1161} 1162 1163type awsAwsjson11_deserializeOpDeleteForecast struct { 1164} 1165 1166func (*awsAwsjson11_deserializeOpDeleteForecast) ID() string { 1167 return "OperationDeserializer" 1168} 1169 1170func (m *awsAwsjson11_deserializeOpDeleteForecast) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1171 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1172) { 1173 out, metadata, err = next.HandleDeserialize(ctx, in) 1174 if err != nil { 1175 return out, metadata, err 1176 } 1177 1178 response, ok := out.RawResponse.(*smithyhttp.Response) 1179 if !ok { 1180 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1181 } 1182 1183 if response.StatusCode < 200 || response.StatusCode >= 300 { 1184 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteForecast(response, &metadata) 1185 } 1186 output := &DeleteForecastOutput{} 1187 out.Result = output 1188 1189 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1190 return out, metadata, &smithy.DeserializationError{ 1191 Err: fmt.Errorf("failed to discard response body, %w", err), 1192 } 1193 } 1194 1195 return out, metadata, err 1196} 1197 1198func awsAwsjson11_deserializeOpErrorDeleteForecast(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1199 var errorBuffer bytes.Buffer 1200 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1201 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1202 } 1203 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1204 1205 errorCode := "UnknownError" 1206 errorMessage := errorCode 1207 1208 code := response.Header.Get("X-Amzn-ErrorType") 1209 if len(code) != 0 { 1210 errorCode = restjson.SanitizeErrorCode(code) 1211 } 1212 1213 var buff [1024]byte 1214 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1215 1216 body := io.TeeReader(errorBody, ringBuffer) 1217 decoder := json.NewDecoder(body) 1218 decoder.UseNumber() 1219 code, message, err := restjson.GetErrorInfo(decoder) 1220 if err != nil { 1221 var snapshot bytes.Buffer 1222 io.Copy(&snapshot, ringBuffer) 1223 err = &smithy.DeserializationError{ 1224 Err: fmt.Errorf("failed to decode response body, %w", err), 1225 Snapshot: snapshot.Bytes(), 1226 } 1227 return err 1228 } 1229 1230 errorBody.Seek(0, io.SeekStart) 1231 if len(code) != 0 { 1232 errorCode = restjson.SanitizeErrorCode(code) 1233 } 1234 if len(message) != 0 { 1235 errorMessage = message 1236 } 1237 1238 switch { 1239 case strings.EqualFold("InvalidInputException", errorCode): 1240 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1241 1242 case strings.EqualFold("ResourceInUseException", errorCode): 1243 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1244 1245 case strings.EqualFold("ResourceNotFoundException", errorCode): 1246 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1247 1248 default: 1249 genericError := &smithy.GenericAPIError{ 1250 Code: errorCode, 1251 Message: errorMessage, 1252 } 1253 return genericError 1254 1255 } 1256} 1257 1258type awsAwsjson11_deserializeOpDeleteForecastExportJob struct { 1259} 1260 1261func (*awsAwsjson11_deserializeOpDeleteForecastExportJob) ID() string { 1262 return "OperationDeserializer" 1263} 1264 1265func (m *awsAwsjson11_deserializeOpDeleteForecastExportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1266 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1267) { 1268 out, metadata, err = next.HandleDeserialize(ctx, in) 1269 if err != nil { 1270 return out, metadata, err 1271 } 1272 1273 response, ok := out.RawResponse.(*smithyhttp.Response) 1274 if !ok { 1275 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1276 } 1277 1278 if response.StatusCode < 200 || response.StatusCode >= 300 { 1279 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteForecastExportJob(response, &metadata) 1280 } 1281 output := &DeleteForecastExportJobOutput{} 1282 out.Result = output 1283 1284 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1285 return out, metadata, &smithy.DeserializationError{ 1286 Err: fmt.Errorf("failed to discard response body, %w", err), 1287 } 1288 } 1289 1290 return out, metadata, err 1291} 1292 1293func awsAwsjson11_deserializeOpErrorDeleteForecastExportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1294 var errorBuffer bytes.Buffer 1295 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1296 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1297 } 1298 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1299 1300 errorCode := "UnknownError" 1301 errorMessage := errorCode 1302 1303 code := response.Header.Get("X-Amzn-ErrorType") 1304 if len(code) != 0 { 1305 errorCode = restjson.SanitizeErrorCode(code) 1306 } 1307 1308 var buff [1024]byte 1309 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1310 1311 body := io.TeeReader(errorBody, ringBuffer) 1312 decoder := json.NewDecoder(body) 1313 decoder.UseNumber() 1314 code, message, err := restjson.GetErrorInfo(decoder) 1315 if err != nil { 1316 var snapshot bytes.Buffer 1317 io.Copy(&snapshot, ringBuffer) 1318 err = &smithy.DeserializationError{ 1319 Err: fmt.Errorf("failed to decode response body, %w", err), 1320 Snapshot: snapshot.Bytes(), 1321 } 1322 return err 1323 } 1324 1325 errorBody.Seek(0, io.SeekStart) 1326 if len(code) != 0 { 1327 errorCode = restjson.SanitizeErrorCode(code) 1328 } 1329 if len(message) != 0 { 1330 errorMessage = message 1331 } 1332 1333 switch { 1334 case strings.EqualFold("InvalidInputException", errorCode): 1335 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1336 1337 case strings.EqualFold("ResourceInUseException", errorCode): 1338 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1339 1340 case strings.EqualFold("ResourceNotFoundException", errorCode): 1341 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1342 1343 default: 1344 genericError := &smithy.GenericAPIError{ 1345 Code: errorCode, 1346 Message: errorMessage, 1347 } 1348 return genericError 1349 1350 } 1351} 1352 1353type awsAwsjson11_deserializeOpDeletePredictor struct { 1354} 1355 1356func (*awsAwsjson11_deserializeOpDeletePredictor) ID() string { 1357 return "OperationDeserializer" 1358} 1359 1360func (m *awsAwsjson11_deserializeOpDeletePredictor) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1361 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1362) { 1363 out, metadata, err = next.HandleDeserialize(ctx, in) 1364 if err != nil { 1365 return out, metadata, err 1366 } 1367 1368 response, ok := out.RawResponse.(*smithyhttp.Response) 1369 if !ok { 1370 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1371 } 1372 1373 if response.StatusCode < 200 || response.StatusCode >= 300 { 1374 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePredictor(response, &metadata) 1375 } 1376 output := &DeletePredictorOutput{} 1377 out.Result = output 1378 1379 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1380 return out, metadata, &smithy.DeserializationError{ 1381 Err: fmt.Errorf("failed to discard response body, %w", err), 1382 } 1383 } 1384 1385 return out, metadata, err 1386} 1387 1388func awsAwsjson11_deserializeOpErrorDeletePredictor(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1389 var errorBuffer bytes.Buffer 1390 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1391 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1392 } 1393 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1394 1395 errorCode := "UnknownError" 1396 errorMessage := errorCode 1397 1398 code := response.Header.Get("X-Amzn-ErrorType") 1399 if len(code) != 0 { 1400 errorCode = restjson.SanitizeErrorCode(code) 1401 } 1402 1403 var buff [1024]byte 1404 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1405 1406 body := io.TeeReader(errorBody, ringBuffer) 1407 decoder := json.NewDecoder(body) 1408 decoder.UseNumber() 1409 code, message, err := restjson.GetErrorInfo(decoder) 1410 if err != nil { 1411 var snapshot bytes.Buffer 1412 io.Copy(&snapshot, ringBuffer) 1413 err = &smithy.DeserializationError{ 1414 Err: fmt.Errorf("failed to decode response body, %w", err), 1415 Snapshot: snapshot.Bytes(), 1416 } 1417 return err 1418 } 1419 1420 errorBody.Seek(0, io.SeekStart) 1421 if len(code) != 0 { 1422 errorCode = restjson.SanitizeErrorCode(code) 1423 } 1424 if len(message) != 0 { 1425 errorMessage = message 1426 } 1427 1428 switch { 1429 case strings.EqualFold("InvalidInputException", errorCode): 1430 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1431 1432 case strings.EqualFold("ResourceInUseException", errorCode): 1433 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1434 1435 case strings.EqualFold("ResourceNotFoundException", errorCode): 1436 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1437 1438 default: 1439 genericError := &smithy.GenericAPIError{ 1440 Code: errorCode, 1441 Message: errorMessage, 1442 } 1443 return genericError 1444 1445 } 1446} 1447 1448type awsAwsjson11_deserializeOpDeletePredictorBacktestExportJob struct { 1449} 1450 1451func (*awsAwsjson11_deserializeOpDeletePredictorBacktestExportJob) ID() string { 1452 return "OperationDeserializer" 1453} 1454 1455func (m *awsAwsjson11_deserializeOpDeletePredictorBacktestExportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1456 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1457) { 1458 out, metadata, err = next.HandleDeserialize(ctx, in) 1459 if err != nil { 1460 return out, metadata, err 1461 } 1462 1463 response, ok := out.RawResponse.(*smithyhttp.Response) 1464 if !ok { 1465 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1466 } 1467 1468 if response.StatusCode < 200 || response.StatusCode >= 300 { 1469 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePredictorBacktestExportJob(response, &metadata) 1470 } 1471 output := &DeletePredictorBacktestExportJobOutput{} 1472 out.Result = output 1473 1474 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1475 return out, metadata, &smithy.DeserializationError{ 1476 Err: fmt.Errorf("failed to discard response body, %w", err), 1477 } 1478 } 1479 1480 return out, metadata, err 1481} 1482 1483func awsAwsjson11_deserializeOpErrorDeletePredictorBacktestExportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1484 var errorBuffer bytes.Buffer 1485 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1486 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1487 } 1488 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1489 1490 errorCode := "UnknownError" 1491 errorMessage := errorCode 1492 1493 code := response.Header.Get("X-Amzn-ErrorType") 1494 if len(code) != 0 { 1495 errorCode = restjson.SanitizeErrorCode(code) 1496 } 1497 1498 var buff [1024]byte 1499 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1500 1501 body := io.TeeReader(errorBody, ringBuffer) 1502 decoder := json.NewDecoder(body) 1503 decoder.UseNumber() 1504 code, message, err := restjson.GetErrorInfo(decoder) 1505 if err != nil { 1506 var snapshot bytes.Buffer 1507 io.Copy(&snapshot, ringBuffer) 1508 err = &smithy.DeserializationError{ 1509 Err: fmt.Errorf("failed to decode response body, %w", err), 1510 Snapshot: snapshot.Bytes(), 1511 } 1512 return err 1513 } 1514 1515 errorBody.Seek(0, io.SeekStart) 1516 if len(code) != 0 { 1517 errorCode = restjson.SanitizeErrorCode(code) 1518 } 1519 if len(message) != 0 { 1520 errorMessage = message 1521 } 1522 1523 switch { 1524 case strings.EqualFold("InvalidInputException", errorCode): 1525 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1526 1527 case strings.EqualFold("ResourceInUseException", errorCode): 1528 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1529 1530 case strings.EqualFold("ResourceNotFoundException", errorCode): 1531 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1532 1533 default: 1534 genericError := &smithy.GenericAPIError{ 1535 Code: errorCode, 1536 Message: errorMessage, 1537 } 1538 return genericError 1539 1540 } 1541} 1542 1543type awsAwsjson11_deserializeOpDescribeDataset struct { 1544} 1545 1546func (*awsAwsjson11_deserializeOpDescribeDataset) ID() string { 1547 return "OperationDeserializer" 1548} 1549 1550func (m *awsAwsjson11_deserializeOpDescribeDataset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1551 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1552) { 1553 out, metadata, err = next.HandleDeserialize(ctx, in) 1554 if err != nil { 1555 return out, metadata, err 1556 } 1557 1558 response, ok := out.RawResponse.(*smithyhttp.Response) 1559 if !ok { 1560 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1561 } 1562 1563 if response.StatusCode < 200 || response.StatusCode >= 300 { 1564 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDataset(response, &metadata) 1565 } 1566 output := &DescribeDatasetOutput{} 1567 out.Result = output 1568 1569 var buff [1024]byte 1570 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1571 1572 body := io.TeeReader(response.Body, ringBuffer) 1573 decoder := json.NewDecoder(body) 1574 decoder.UseNumber() 1575 var shape interface{} 1576 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1577 var snapshot bytes.Buffer 1578 io.Copy(&snapshot, ringBuffer) 1579 err = &smithy.DeserializationError{ 1580 Err: fmt.Errorf("failed to decode response body, %w", err), 1581 Snapshot: snapshot.Bytes(), 1582 } 1583 return out, metadata, err 1584 } 1585 1586 err = awsAwsjson11_deserializeOpDocumentDescribeDatasetOutput(&output, shape) 1587 if err != nil { 1588 var snapshot bytes.Buffer 1589 io.Copy(&snapshot, ringBuffer) 1590 err = &smithy.DeserializationError{ 1591 Err: fmt.Errorf("failed to decode response body, %w", err), 1592 Snapshot: snapshot.Bytes(), 1593 } 1594 return out, metadata, err 1595 } 1596 1597 return out, metadata, err 1598} 1599 1600func awsAwsjson11_deserializeOpErrorDescribeDataset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1601 var errorBuffer bytes.Buffer 1602 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1603 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1604 } 1605 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1606 1607 errorCode := "UnknownError" 1608 errorMessage := errorCode 1609 1610 code := response.Header.Get("X-Amzn-ErrorType") 1611 if len(code) != 0 { 1612 errorCode = restjson.SanitizeErrorCode(code) 1613 } 1614 1615 var buff [1024]byte 1616 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1617 1618 body := io.TeeReader(errorBody, ringBuffer) 1619 decoder := json.NewDecoder(body) 1620 decoder.UseNumber() 1621 code, message, err := restjson.GetErrorInfo(decoder) 1622 if err != nil { 1623 var snapshot bytes.Buffer 1624 io.Copy(&snapshot, ringBuffer) 1625 err = &smithy.DeserializationError{ 1626 Err: fmt.Errorf("failed to decode response body, %w", err), 1627 Snapshot: snapshot.Bytes(), 1628 } 1629 return err 1630 } 1631 1632 errorBody.Seek(0, io.SeekStart) 1633 if len(code) != 0 { 1634 errorCode = restjson.SanitizeErrorCode(code) 1635 } 1636 if len(message) != 0 { 1637 errorMessage = message 1638 } 1639 1640 switch { 1641 case strings.EqualFold("InvalidInputException", errorCode): 1642 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1643 1644 case strings.EqualFold("ResourceNotFoundException", errorCode): 1645 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1646 1647 default: 1648 genericError := &smithy.GenericAPIError{ 1649 Code: errorCode, 1650 Message: errorMessage, 1651 } 1652 return genericError 1653 1654 } 1655} 1656 1657type awsAwsjson11_deserializeOpDescribeDatasetGroup struct { 1658} 1659 1660func (*awsAwsjson11_deserializeOpDescribeDatasetGroup) ID() string { 1661 return "OperationDeserializer" 1662} 1663 1664func (m *awsAwsjson11_deserializeOpDescribeDatasetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1665 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1666) { 1667 out, metadata, err = next.HandleDeserialize(ctx, in) 1668 if err != nil { 1669 return out, metadata, err 1670 } 1671 1672 response, ok := out.RawResponse.(*smithyhttp.Response) 1673 if !ok { 1674 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1675 } 1676 1677 if response.StatusCode < 200 || response.StatusCode >= 300 { 1678 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDatasetGroup(response, &metadata) 1679 } 1680 output := &DescribeDatasetGroupOutput{} 1681 out.Result = output 1682 1683 var buff [1024]byte 1684 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1685 1686 body := io.TeeReader(response.Body, ringBuffer) 1687 decoder := json.NewDecoder(body) 1688 decoder.UseNumber() 1689 var shape interface{} 1690 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1691 var snapshot bytes.Buffer 1692 io.Copy(&snapshot, ringBuffer) 1693 err = &smithy.DeserializationError{ 1694 Err: fmt.Errorf("failed to decode response body, %w", err), 1695 Snapshot: snapshot.Bytes(), 1696 } 1697 return out, metadata, err 1698 } 1699 1700 err = awsAwsjson11_deserializeOpDocumentDescribeDatasetGroupOutput(&output, shape) 1701 if err != nil { 1702 var snapshot bytes.Buffer 1703 io.Copy(&snapshot, ringBuffer) 1704 err = &smithy.DeserializationError{ 1705 Err: fmt.Errorf("failed to decode response body, %w", err), 1706 Snapshot: snapshot.Bytes(), 1707 } 1708 return out, metadata, err 1709 } 1710 1711 return out, metadata, err 1712} 1713 1714func awsAwsjson11_deserializeOpErrorDescribeDatasetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1715 var errorBuffer bytes.Buffer 1716 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1717 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1718 } 1719 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1720 1721 errorCode := "UnknownError" 1722 errorMessage := errorCode 1723 1724 code := response.Header.Get("X-Amzn-ErrorType") 1725 if len(code) != 0 { 1726 errorCode = restjson.SanitizeErrorCode(code) 1727 } 1728 1729 var buff [1024]byte 1730 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1731 1732 body := io.TeeReader(errorBody, ringBuffer) 1733 decoder := json.NewDecoder(body) 1734 decoder.UseNumber() 1735 code, message, err := restjson.GetErrorInfo(decoder) 1736 if err != nil { 1737 var snapshot bytes.Buffer 1738 io.Copy(&snapshot, ringBuffer) 1739 err = &smithy.DeserializationError{ 1740 Err: fmt.Errorf("failed to decode response body, %w", err), 1741 Snapshot: snapshot.Bytes(), 1742 } 1743 return err 1744 } 1745 1746 errorBody.Seek(0, io.SeekStart) 1747 if len(code) != 0 { 1748 errorCode = restjson.SanitizeErrorCode(code) 1749 } 1750 if len(message) != 0 { 1751 errorMessage = message 1752 } 1753 1754 switch { 1755 case strings.EqualFold("InvalidInputException", errorCode): 1756 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1757 1758 case strings.EqualFold("ResourceNotFoundException", errorCode): 1759 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1760 1761 default: 1762 genericError := &smithy.GenericAPIError{ 1763 Code: errorCode, 1764 Message: errorMessage, 1765 } 1766 return genericError 1767 1768 } 1769} 1770 1771type awsAwsjson11_deserializeOpDescribeDatasetImportJob struct { 1772} 1773 1774func (*awsAwsjson11_deserializeOpDescribeDatasetImportJob) ID() string { 1775 return "OperationDeserializer" 1776} 1777 1778func (m *awsAwsjson11_deserializeOpDescribeDatasetImportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1779 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1780) { 1781 out, metadata, err = next.HandleDeserialize(ctx, in) 1782 if err != nil { 1783 return out, metadata, err 1784 } 1785 1786 response, ok := out.RawResponse.(*smithyhttp.Response) 1787 if !ok { 1788 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1789 } 1790 1791 if response.StatusCode < 200 || response.StatusCode >= 300 { 1792 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDatasetImportJob(response, &metadata) 1793 } 1794 output := &DescribeDatasetImportJobOutput{} 1795 out.Result = output 1796 1797 var buff [1024]byte 1798 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1799 1800 body := io.TeeReader(response.Body, ringBuffer) 1801 decoder := json.NewDecoder(body) 1802 decoder.UseNumber() 1803 var shape interface{} 1804 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1805 var snapshot bytes.Buffer 1806 io.Copy(&snapshot, ringBuffer) 1807 err = &smithy.DeserializationError{ 1808 Err: fmt.Errorf("failed to decode response body, %w", err), 1809 Snapshot: snapshot.Bytes(), 1810 } 1811 return out, metadata, err 1812 } 1813 1814 err = awsAwsjson11_deserializeOpDocumentDescribeDatasetImportJobOutput(&output, shape) 1815 if err != nil { 1816 var snapshot bytes.Buffer 1817 io.Copy(&snapshot, ringBuffer) 1818 err = &smithy.DeserializationError{ 1819 Err: fmt.Errorf("failed to decode response body, %w", err), 1820 Snapshot: snapshot.Bytes(), 1821 } 1822 return out, metadata, err 1823 } 1824 1825 return out, metadata, err 1826} 1827 1828func awsAwsjson11_deserializeOpErrorDescribeDatasetImportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1829 var errorBuffer bytes.Buffer 1830 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1831 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1832 } 1833 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1834 1835 errorCode := "UnknownError" 1836 errorMessage := errorCode 1837 1838 code := response.Header.Get("X-Amzn-ErrorType") 1839 if len(code) != 0 { 1840 errorCode = restjson.SanitizeErrorCode(code) 1841 } 1842 1843 var buff [1024]byte 1844 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1845 1846 body := io.TeeReader(errorBody, ringBuffer) 1847 decoder := json.NewDecoder(body) 1848 decoder.UseNumber() 1849 code, message, err := restjson.GetErrorInfo(decoder) 1850 if err != nil { 1851 var snapshot bytes.Buffer 1852 io.Copy(&snapshot, ringBuffer) 1853 err = &smithy.DeserializationError{ 1854 Err: fmt.Errorf("failed to decode response body, %w", err), 1855 Snapshot: snapshot.Bytes(), 1856 } 1857 return err 1858 } 1859 1860 errorBody.Seek(0, io.SeekStart) 1861 if len(code) != 0 { 1862 errorCode = restjson.SanitizeErrorCode(code) 1863 } 1864 if len(message) != 0 { 1865 errorMessage = message 1866 } 1867 1868 switch { 1869 case strings.EqualFold("InvalidInputException", errorCode): 1870 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1871 1872 case strings.EqualFold("ResourceNotFoundException", errorCode): 1873 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1874 1875 default: 1876 genericError := &smithy.GenericAPIError{ 1877 Code: errorCode, 1878 Message: errorMessage, 1879 } 1880 return genericError 1881 1882 } 1883} 1884 1885type awsAwsjson11_deserializeOpDescribeForecast struct { 1886} 1887 1888func (*awsAwsjson11_deserializeOpDescribeForecast) ID() string { 1889 return "OperationDeserializer" 1890} 1891 1892func (m *awsAwsjson11_deserializeOpDescribeForecast) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1893 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1894) { 1895 out, metadata, err = next.HandleDeserialize(ctx, in) 1896 if err != nil { 1897 return out, metadata, err 1898 } 1899 1900 response, ok := out.RawResponse.(*smithyhttp.Response) 1901 if !ok { 1902 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1903 } 1904 1905 if response.StatusCode < 200 || response.StatusCode >= 300 { 1906 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeForecast(response, &metadata) 1907 } 1908 output := &DescribeForecastOutput{} 1909 out.Result = output 1910 1911 var buff [1024]byte 1912 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1913 1914 body := io.TeeReader(response.Body, ringBuffer) 1915 decoder := json.NewDecoder(body) 1916 decoder.UseNumber() 1917 var shape interface{} 1918 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1919 var snapshot bytes.Buffer 1920 io.Copy(&snapshot, ringBuffer) 1921 err = &smithy.DeserializationError{ 1922 Err: fmt.Errorf("failed to decode response body, %w", err), 1923 Snapshot: snapshot.Bytes(), 1924 } 1925 return out, metadata, err 1926 } 1927 1928 err = awsAwsjson11_deserializeOpDocumentDescribeForecastOutput(&output, shape) 1929 if err != nil { 1930 var snapshot bytes.Buffer 1931 io.Copy(&snapshot, ringBuffer) 1932 err = &smithy.DeserializationError{ 1933 Err: fmt.Errorf("failed to decode response body, %w", err), 1934 Snapshot: snapshot.Bytes(), 1935 } 1936 return out, metadata, err 1937 } 1938 1939 return out, metadata, err 1940} 1941 1942func awsAwsjson11_deserializeOpErrorDescribeForecast(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1943 var errorBuffer bytes.Buffer 1944 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1945 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1946 } 1947 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1948 1949 errorCode := "UnknownError" 1950 errorMessage := errorCode 1951 1952 code := response.Header.Get("X-Amzn-ErrorType") 1953 if len(code) != 0 { 1954 errorCode = restjson.SanitizeErrorCode(code) 1955 } 1956 1957 var buff [1024]byte 1958 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1959 1960 body := io.TeeReader(errorBody, ringBuffer) 1961 decoder := json.NewDecoder(body) 1962 decoder.UseNumber() 1963 code, message, err := restjson.GetErrorInfo(decoder) 1964 if err != nil { 1965 var snapshot bytes.Buffer 1966 io.Copy(&snapshot, ringBuffer) 1967 err = &smithy.DeserializationError{ 1968 Err: fmt.Errorf("failed to decode response body, %w", err), 1969 Snapshot: snapshot.Bytes(), 1970 } 1971 return err 1972 } 1973 1974 errorBody.Seek(0, io.SeekStart) 1975 if len(code) != 0 { 1976 errorCode = restjson.SanitizeErrorCode(code) 1977 } 1978 if len(message) != 0 { 1979 errorMessage = message 1980 } 1981 1982 switch { 1983 case strings.EqualFold("InvalidInputException", errorCode): 1984 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1985 1986 case strings.EqualFold("ResourceNotFoundException", errorCode): 1987 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1988 1989 default: 1990 genericError := &smithy.GenericAPIError{ 1991 Code: errorCode, 1992 Message: errorMessage, 1993 } 1994 return genericError 1995 1996 } 1997} 1998 1999type awsAwsjson11_deserializeOpDescribeForecastExportJob struct { 2000} 2001 2002func (*awsAwsjson11_deserializeOpDescribeForecastExportJob) ID() string { 2003 return "OperationDeserializer" 2004} 2005 2006func (m *awsAwsjson11_deserializeOpDescribeForecastExportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2007 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2008) { 2009 out, metadata, err = next.HandleDeserialize(ctx, in) 2010 if err != nil { 2011 return out, metadata, err 2012 } 2013 2014 response, ok := out.RawResponse.(*smithyhttp.Response) 2015 if !ok { 2016 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2017 } 2018 2019 if response.StatusCode < 200 || response.StatusCode >= 300 { 2020 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeForecastExportJob(response, &metadata) 2021 } 2022 output := &DescribeForecastExportJobOutput{} 2023 out.Result = output 2024 2025 var buff [1024]byte 2026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2027 2028 body := io.TeeReader(response.Body, ringBuffer) 2029 decoder := json.NewDecoder(body) 2030 decoder.UseNumber() 2031 var shape interface{} 2032 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2033 var snapshot bytes.Buffer 2034 io.Copy(&snapshot, ringBuffer) 2035 err = &smithy.DeserializationError{ 2036 Err: fmt.Errorf("failed to decode response body, %w", err), 2037 Snapshot: snapshot.Bytes(), 2038 } 2039 return out, metadata, err 2040 } 2041 2042 err = awsAwsjson11_deserializeOpDocumentDescribeForecastExportJobOutput(&output, shape) 2043 if err != nil { 2044 var snapshot bytes.Buffer 2045 io.Copy(&snapshot, ringBuffer) 2046 err = &smithy.DeserializationError{ 2047 Err: fmt.Errorf("failed to decode response body, %w", err), 2048 Snapshot: snapshot.Bytes(), 2049 } 2050 return out, metadata, err 2051 } 2052 2053 return out, metadata, err 2054} 2055 2056func awsAwsjson11_deserializeOpErrorDescribeForecastExportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2057 var errorBuffer bytes.Buffer 2058 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2059 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2060 } 2061 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2062 2063 errorCode := "UnknownError" 2064 errorMessage := errorCode 2065 2066 code := response.Header.Get("X-Amzn-ErrorType") 2067 if len(code) != 0 { 2068 errorCode = restjson.SanitizeErrorCode(code) 2069 } 2070 2071 var buff [1024]byte 2072 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2073 2074 body := io.TeeReader(errorBody, ringBuffer) 2075 decoder := json.NewDecoder(body) 2076 decoder.UseNumber() 2077 code, message, err := restjson.GetErrorInfo(decoder) 2078 if err != nil { 2079 var snapshot bytes.Buffer 2080 io.Copy(&snapshot, ringBuffer) 2081 err = &smithy.DeserializationError{ 2082 Err: fmt.Errorf("failed to decode response body, %w", err), 2083 Snapshot: snapshot.Bytes(), 2084 } 2085 return err 2086 } 2087 2088 errorBody.Seek(0, io.SeekStart) 2089 if len(code) != 0 { 2090 errorCode = restjson.SanitizeErrorCode(code) 2091 } 2092 if len(message) != 0 { 2093 errorMessage = message 2094 } 2095 2096 switch { 2097 case strings.EqualFold("InvalidInputException", errorCode): 2098 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2099 2100 case strings.EqualFold("ResourceNotFoundException", errorCode): 2101 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2102 2103 default: 2104 genericError := &smithy.GenericAPIError{ 2105 Code: errorCode, 2106 Message: errorMessage, 2107 } 2108 return genericError 2109 2110 } 2111} 2112 2113type awsAwsjson11_deserializeOpDescribePredictor struct { 2114} 2115 2116func (*awsAwsjson11_deserializeOpDescribePredictor) ID() string { 2117 return "OperationDeserializer" 2118} 2119 2120func (m *awsAwsjson11_deserializeOpDescribePredictor) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2121 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2122) { 2123 out, metadata, err = next.HandleDeserialize(ctx, in) 2124 if err != nil { 2125 return out, metadata, err 2126 } 2127 2128 response, ok := out.RawResponse.(*smithyhttp.Response) 2129 if !ok { 2130 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2131 } 2132 2133 if response.StatusCode < 200 || response.StatusCode >= 300 { 2134 return out, metadata, awsAwsjson11_deserializeOpErrorDescribePredictor(response, &metadata) 2135 } 2136 output := &DescribePredictorOutput{} 2137 out.Result = output 2138 2139 var buff [1024]byte 2140 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2141 2142 body := io.TeeReader(response.Body, ringBuffer) 2143 decoder := json.NewDecoder(body) 2144 decoder.UseNumber() 2145 var shape interface{} 2146 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2147 var snapshot bytes.Buffer 2148 io.Copy(&snapshot, ringBuffer) 2149 err = &smithy.DeserializationError{ 2150 Err: fmt.Errorf("failed to decode response body, %w", err), 2151 Snapshot: snapshot.Bytes(), 2152 } 2153 return out, metadata, err 2154 } 2155 2156 err = awsAwsjson11_deserializeOpDocumentDescribePredictorOutput(&output, shape) 2157 if err != nil { 2158 var snapshot bytes.Buffer 2159 io.Copy(&snapshot, ringBuffer) 2160 err = &smithy.DeserializationError{ 2161 Err: fmt.Errorf("failed to decode response body, %w", err), 2162 Snapshot: snapshot.Bytes(), 2163 } 2164 return out, metadata, err 2165 } 2166 2167 return out, metadata, err 2168} 2169 2170func awsAwsjson11_deserializeOpErrorDescribePredictor(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2171 var errorBuffer bytes.Buffer 2172 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2173 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2174 } 2175 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2176 2177 errorCode := "UnknownError" 2178 errorMessage := errorCode 2179 2180 code := response.Header.Get("X-Amzn-ErrorType") 2181 if len(code) != 0 { 2182 errorCode = restjson.SanitizeErrorCode(code) 2183 } 2184 2185 var buff [1024]byte 2186 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2187 2188 body := io.TeeReader(errorBody, ringBuffer) 2189 decoder := json.NewDecoder(body) 2190 decoder.UseNumber() 2191 code, message, err := restjson.GetErrorInfo(decoder) 2192 if err != nil { 2193 var snapshot bytes.Buffer 2194 io.Copy(&snapshot, ringBuffer) 2195 err = &smithy.DeserializationError{ 2196 Err: fmt.Errorf("failed to decode response body, %w", err), 2197 Snapshot: snapshot.Bytes(), 2198 } 2199 return err 2200 } 2201 2202 errorBody.Seek(0, io.SeekStart) 2203 if len(code) != 0 { 2204 errorCode = restjson.SanitizeErrorCode(code) 2205 } 2206 if len(message) != 0 { 2207 errorMessage = message 2208 } 2209 2210 switch { 2211 case strings.EqualFold("InvalidInputException", errorCode): 2212 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2213 2214 case strings.EqualFold("ResourceNotFoundException", errorCode): 2215 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2216 2217 default: 2218 genericError := &smithy.GenericAPIError{ 2219 Code: errorCode, 2220 Message: errorMessage, 2221 } 2222 return genericError 2223 2224 } 2225} 2226 2227type awsAwsjson11_deserializeOpDescribePredictorBacktestExportJob struct { 2228} 2229 2230func (*awsAwsjson11_deserializeOpDescribePredictorBacktestExportJob) ID() string { 2231 return "OperationDeserializer" 2232} 2233 2234func (m *awsAwsjson11_deserializeOpDescribePredictorBacktestExportJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2235 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2236) { 2237 out, metadata, err = next.HandleDeserialize(ctx, in) 2238 if err != nil { 2239 return out, metadata, err 2240 } 2241 2242 response, ok := out.RawResponse.(*smithyhttp.Response) 2243 if !ok { 2244 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2245 } 2246 2247 if response.StatusCode < 200 || response.StatusCode >= 300 { 2248 return out, metadata, awsAwsjson11_deserializeOpErrorDescribePredictorBacktestExportJob(response, &metadata) 2249 } 2250 output := &DescribePredictorBacktestExportJobOutput{} 2251 out.Result = output 2252 2253 var buff [1024]byte 2254 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2255 2256 body := io.TeeReader(response.Body, ringBuffer) 2257 decoder := json.NewDecoder(body) 2258 decoder.UseNumber() 2259 var shape interface{} 2260 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2261 var snapshot bytes.Buffer 2262 io.Copy(&snapshot, ringBuffer) 2263 err = &smithy.DeserializationError{ 2264 Err: fmt.Errorf("failed to decode response body, %w", err), 2265 Snapshot: snapshot.Bytes(), 2266 } 2267 return out, metadata, err 2268 } 2269 2270 err = awsAwsjson11_deserializeOpDocumentDescribePredictorBacktestExportJobOutput(&output, shape) 2271 if err != nil { 2272 var snapshot bytes.Buffer 2273 io.Copy(&snapshot, ringBuffer) 2274 err = &smithy.DeserializationError{ 2275 Err: fmt.Errorf("failed to decode response body, %w", err), 2276 Snapshot: snapshot.Bytes(), 2277 } 2278 return out, metadata, err 2279 } 2280 2281 return out, metadata, err 2282} 2283 2284func awsAwsjson11_deserializeOpErrorDescribePredictorBacktestExportJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2285 var errorBuffer bytes.Buffer 2286 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2287 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2288 } 2289 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2290 2291 errorCode := "UnknownError" 2292 errorMessage := errorCode 2293 2294 code := response.Header.Get("X-Amzn-ErrorType") 2295 if len(code) != 0 { 2296 errorCode = restjson.SanitizeErrorCode(code) 2297 } 2298 2299 var buff [1024]byte 2300 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2301 2302 body := io.TeeReader(errorBody, ringBuffer) 2303 decoder := json.NewDecoder(body) 2304 decoder.UseNumber() 2305 code, message, err := restjson.GetErrorInfo(decoder) 2306 if err != nil { 2307 var snapshot bytes.Buffer 2308 io.Copy(&snapshot, ringBuffer) 2309 err = &smithy.DeserializationError{ 2310 Err: fmt.Errorf("failed to decode response body, %w", err), 2311 Snapshot: snapshot.Bytes(), 2312 } 2313 return err 2314 } 2315 2316 errorBody.Seek(0, io.SeekStart) 2317 if len(code) != 0 { 2318 errorCode = restjson.SanitizeErrorCode(code) 2319 } 2320 if len(message) != 0 { 2321 errorMessage = message 2322 } 2323 2324 switch { 2325 case strings.EqualFold("InvalidInputException", errorCode): 2326 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2327 2328 case strings.EqualFold("ResourceNotFoundException", errorCode): 2329 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2330 2331 default: 2332 genericError := &smithy.GenericAPIError{ 2333 Code: errorCode, 2334 Message: errorMessage, 2335 } 2336 return genericError 2337 2338 } 2339} 2340 2341type awsAwsjson11_deserializeOpGetAccuracyMetrics struct { 2342} 2343 2344func (*awsAwsjson11_deserializeOpGetAccuracyMetrics) ID() string { 2345 return "OperationDeserializer" 2346} 2347 2348func (m *awsAwsjson11_deserializeOpGetAccuracyMetrics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2349 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2350) { 2351 out, metadata, err = next.HandleDeserialize(ctx, in) 2352 if err != nil { 2353 return out, metadata, err 2354 } 2355 2356 response, ok := out.RawResponse.(*smithyhttp.Response) 2357 if !ok { 2358 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2359 } 2360 2361 if response.StatusCode < 200 || response.StatusCode >= 300 { 2362 return out, metadata, awsAwsjson11_deserializeOpErrorGetAccuracyMetrics(response, &metadata) 2363 } 2364 output := &GetAccuracyMetricsOutput{} 2365 out.Result = output 2366 2367 var buff [1024]byte 2368 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2369 2370 body := io.TeeReader(response.Body, ringBuffer) 2371 decoder := json.NewDecoder(body) 2372 decoder.UseNumber() 2373 var shape interface{} 2374 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2375 var snapshot bytes.Buffer 2376 io.Copy(&snapshot, ringBuffer) 2377 err = &smithy.DeserializationError{ 2378 Err: fmt.Errorf("failed to decode response body, %w", err), 2379 Snapshot: snapshot.Bytes(), 2380 } 2381 return out, metadata, err 2382 } 2383 2384 err = awsAwsjson11_deserializeOpDocumentGetAccuracyMetricsOutput(&output, shape) 2385 if err != nil { 2386 var snapshot bytes.Buffer 2387 io.Copy(&snapshot, ringBuffer) 2388 err = &smithy.DeserializationError{ 2389 Err: fmt.Errorf("failed to decode response body, %w", err), 2390 Snapshot: snapshot.Bytes(), 2391 } 2392 return out, metadata, err 2393 } 2394 2395 return out, metadata, err 2396} 2397 2398func awsAwsjson11_deserializeOpErrorGetAccuracyMetrics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2399 var errorBuffer bytes.Buffer 2400 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2401 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2402 } 2403 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2404 2405 errorCode := "UnknownError" 2406 errorMessage := errorCode 2407 2408 code := response.Header.Get("X-Amzn-ErrorType") 2409 if len(code) != 0 { 2410 errorCode = restjson.SanitizeErrorCode(code) 2411 } 2412 2413 var buff [1024]byte 2414 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2415 2416 body := io.TeeReader(errorBody, ringBuffer) 2417 decoder := json.NewDecoder(body) 2418 decoder.UseNumber() 2419 code, message, err := restjson.GetErrorInfo(decoder) 2420 if err != nil { 2421 var snapshot bytes.Buffer 2422 io.Copy(&snapshot, ringBuffer) 2423 err = &smithy.DeserializationError{ 2424 Err: fmt.Errorf("failed to decode response body, %w", err), 2425 Snapshot: snapshot.Bytes(), 2426 } 2427 return err 2428 } 2429 2430 errorBody.Seek(0, io.SeekStart) 2431 if len(code) != 0 { 2432 errorCode = restjson.SanitizeErrorCode(code) 2433 } 2434 if len(message) != 0 { 2435 errorMessage = message 2436 } 2437 2438 switch { 2439 case strings.EqualFold("InvalidInputException", errorCode): 2440 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2441 2442 case strings.EqualFold("ResourceInUseException", errorCode): 2443 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2444 2445 case strings.EqualFold("ResourceNotFoundException", errorCode): 2446 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2447 2448 default: 2449 genericError := &smithy.GenericAPIError{ 2450 Code: errorCode, 2451 Message: errorMessage, 2452 } 2453 return genericError 2454 2455 } 2456} 2457 2458type awsAwsjson11_deserializeOpListDatasetGroups struct { 2459} 2460 2461func (*awsAwsjson11_deserializeOpListDatasetGroups) ID() string { 2462 return "OperationDeserializer" 2463} 2464 2465func (m *awsAwsjson11_deserializeOpListDatasetGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2466 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2467) { 2468 out, metadata, err = next.HandleDeserialize(ctx, in) 2469 if err != nil { 2470 return out, metadata, err 2471 } 2472 2473 response, ok := out.RawResponse.(*smithyhttp.Response) 2474 if !ok { 2475 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2476 } 2477 2478 if response.StatusCode < 200 || response.StatusCode >= 300 { 2479 return out, metadata, awsAwsjson11_deserializeOpErrorListDatasetGroups(response, &metadata) 2480 } 2481 output := &ListDatasetGroupsOutput{} 2482 out.Result = output 2483 2484 var buff [1024]byte 2485 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2486 2487 body := io.TeeReader(response.Body, ringBuffer) 2488 decoder := json.NewDecoder(body) 2489 decoder.UseNumber() 2490 var shape interface{} 2491 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2492 var snapshot bytes.Buffer 2493 io.Copy(&snapshot, ringBuffer) 2494 err = &smithy.DeserializationError{ 2495 Err: fmt.Errorf("failed to decode response body, %w", err), 2496 Snapshot: snapshot.Bytes(), 2497 } 2498 return out, metadata, err 2499 } 2500 2501 err = awsAwsjson11_deserializeOpDocumentListDatasetGroupsOutput(&output, shape) 2502 if err != nil { 2503 var snapshot bytes.Buffer 2504 io.Copy(&snapshot, ringBuffer) 2505 err = &smithy.DeserializationError{ 2506 Err: fmt.Errorf("failed to decode response body, %w", err), 2507 Snapshot: snapshot.Bytes(), 2508 } 2509 return out, metadata, err 2510 } 2511 2512 return out, metadata, err 2513} 2514 2515func awsAwsjson11_deserializeOpErrorListDatasetGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2516 var errorBuffer bytes.Buffer 2517 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2518 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2519 } 2520 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2521 2522 errorCode := "UnknownError" 2523 errorMessage := errorCode 2524 2525 code := response.Header.Get("X-Amzn-ErrorType") 2526 if len(code) != 0 { 2527 errorCode = restjson.SanitizeErrorCode(code) 2528 } 2529 2530 var buff [1024]byte 2531 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2532 2533 body := io.TeeReader(errorBody, ringBuffer) 2534 decoder := json.NewDecoder(body) 2535 decoder.UseNumber() 2536 code, message, err := restjson.GetErrorInfo(decoder) 2537 if err != nil { 2538 var snapshot bytes.Buffer 2539 io.Copy(&snapshot, ringBuffer) 2540 err = &smithy.DeserializationError{ 2541 Err: fmt.Errorf("failed to decode response body, %w", err), 2542 Snapshot: snapshot.Bytes(), 2543 } 2544 return err 2545 } 2546 2547 errorBody.Seek(0, io.SeekStart) 2548 if len(code) != 0 { 2549 errorCode = restjson.SanitizeErrorCode(code) 2550 } 2551 if len(message) != 0 { 2552 errorMessage = message 2553 } 2554 2555 switch { 2556 case strings.EqualFold("InvalidNextTokenException", errorCode): 2557 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2558 2559 default: 2560 genericError := &smithy.GenericAPIError{ 2561 Code: errorCode, 2562 Message: errorMessage, 2563 } 2564 return genericError 2565 2566 } 2567} 2568 2569type awsAwsjson11_deserializeOpListDatasetImportJobs struct { 2570} 2571 2572func (*awsAwsjson11_deserializeOpListDatasetImportJobs) ID() string { 2573 return "OperationDeserializer" 2574} 2575 2576func (m *awsAwsjson11_deserializeOpListDatasetImportJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2577 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2578) { 2579 out, metadata, err = next.HandleDeserialize(ctx, in) 2580 if err != nil { 2581 return out, metadata, err 2582 } 2583 2584 response, ok := out.RawResponse.(*smithyhttp.Response) 2585 if !ok { 2586 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2587 } 2588 2589 if response.StatusCode < 200 || response.StatusCode >= 300 { 2590 return out, metadata, awsAwsjson11_deserializeOpErrorListDatasetImportJobs(response, &metadata) 2591 } 2592 output := &ListDatasetImportJobsOutput{} 2593 out.Result = output 2594 2595 var buff [1024]byte 2596 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2597 2598 body := io.TeeReader(response.Body, ringBuffer) 2599 decoder := json.NewDecoder(body) 2600 decoder.UseNumber() 2601 var shape interface{} 2602 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2603 var snapshot bytes.Buffer 2604 io.Copy(&snapshot, ringBuffer) 2605 err = &smithy.DeserializationError{ 2606 Err: fmt.Errorf("failed to decode response body, %w", err), 2607 Snapshot: snapshot.Bytes(), 2608 } 2609 return out, metadata, err 2610 } 2611 2612 err = awsAwsjson11_deserializeOpDocumentListDatasetImportJobsOutput(&output, shape) 2613 if err != nil { 2614 var snapshot bytes.Buffer 2615 io.Copy(&snapshot, ringBuffer) 2616 err = &smithy.DeserializationError{ 2617 Err: fmt.Errorf("failed to decode response body, %w", err), 2618 Snapshot: snapshot.Bytes(), 2619 } 2620 return out, metadata, err 2621 } 2622 2623 return out, metadata, err 2624} 2625 2626func awsAwsjson11_deserializeOpErrorListDatasetImportJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2627 var errorBuffer bytes.Buffer 2628 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2629 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2630 } 2631 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2632 2633 errorCode := "UnknownError" 2634 errorMessage := errorCode 2635 2636 code := response.Header.Get("X-Amzn-ErrorType") 2637 if len(code) != 0 { 2638 errorCode = restjson.SanitizeErrorCode(code) 2639 } 2640 2641 var buff [1024]byte 2642 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2643 2644 body := io.TeeReader(errorBody, ringBuffer) 2645 decoder := json.NewDecoder(body) 2646 decoder.UseNumber() 2647 code, message, err := restjson.GetErrorInfo(decoder) 2648 if err != nil { 2649 var snapshot bytes.Buffer 2650 io.Copy(&snapshot, ringBuffer) 2651 err = &smithy.DeserializationError{ 2652 Err: fmt.Errorf("failed to decode response body, %w", err), 2653 Snapshot: snapshot.Bytes(), 2654 } 2655 return err 2656 } 2657 2658 errorBody.Seek(0, io.SeekStart) 2659 if len(code) != 0 { 2660 errorCode = restjson.SanitizeErrorCode(code) 2661 } 2662 if len(message) != 0 { 2663 errorMessage = message 2664 } 2665 2666 switch { 2667 case strings.EqualFold("InvalidInputException", errorCode): 2668 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2669 2670 case strings.EqualFold("InvalidNextTokenException", errorCode): 2671 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2672 2673 default: 2674 genericError := &smithy.GenericAPIError{ 2675 Code: errorCode, 2676 Message: errorMessage, 2677 } 2678 return genericError 2679 2680 } 2681} 2682 2683type awsAwsjson11_deserializeOpListDatasets struct { 2684} 2685 2686func (*awsAwsjson11_deserializeOpListDatasets) ID() string { 2687 return "OperationDeserializer" 2688} 2689 2690func (m *awsAwsjson11_deserializeOpListDatasets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2691 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2692) { 2693 out, metadata, err = next.HandleDeserialize(ctx, in) 2694 if err != nil { 2695 return out, metadata, err 2696 } 2697 2698 response, ok := out.RawResponse.(*smithyhttp.Response) 2699 if !ok { 2700 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2701 } 2702 2703 if response.StatusCode < 200 || response.StatusCode >= 300 { 2704 return out, metadata, awsAwsjson11_deserializeOpErrorListDatasets(response, &metadata) 2705 } 2706 output := &ListDatasetsOutput{} 2707 out.Result = output 2708 2709 var buff [1024]byte 2710 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2711 2712 body := io.TeeReader(response.Body, ringBuffer) 2713 decoder := json.NewDecoder(body) 2714 decoder.UseNumber() 2715 var shape interface{} 2716 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2717 var snapshot bytes.Buffer 2718 io.Copy(&snapshot, ringBuffer) 2719 err = &smithy.DeserializationError{ 2720 Err: fmt.Errorf("failed to decode response body, %w", err), 2721 Snapshot: snapshot.Bytes(), 2722 } 2723 return out, metadata, err 2724 } 2725 2726 err = awsAwsjson11_deserializeOpDocumentListDatasetsOutput(&output, shape) 2727 if err != nil { 2728 var snapshot bytes.Buffer 2729 io.Copy(&snapshot, ringBuffer) 2730 err = &smithy.DeserializationError{ 2731 Err: fmt.Errorf("failed to decode response body, %w", err), 2732 Snapshot: snapshot.Bytes(), 2733 } 2734 return out, metadata, err 2735 } 2736 2737 return out, metadata, err 2738} 2739 2740func awsAwsjson11_deserializeOpErrorListDatasets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2741 var errorBuffer bytes.Buffer 2742 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2743 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2744 } 2745 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2746 2747 errorCode := "UnknownError" 2748 errorMessage := errorCode 2749 2750 code := response.Header.Get("X-Amzn-ErrorType") 2751 if len(code) != 0 { 2752 errorCode = restjson.SanitizeErrorCode(code) 2753 } 2754 2755 var buff [1024]byte 2756 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2757 2758 body := io.TeeReader(errorBody, ringBuffer) 2759 decoder := json.NewDecoder(body) 2760 decoder.UseNumber() 2761 code, message, err := restjson.GetErrorInfo(decoder) 2762 if err != nil { 2763 var snapshot bytes.Buffer 2764 io.Copy(&snapshot, ringBuffer) 2765 err = &smithy.DeserializationError{ 2766 Err: fmt.Errorf("failed to decode response body, %w", err), 2767 Snapshot: snapshot.Bytes(), 2768 } 2769 return err 2770 } 2771 2772 errorBody.Seek(0, io.SeekStart) 2773 if len(code) != 0 { 2774 errorCode = restjson.SanitizeErrorCode(code) 2775 } 2776 if len(message) != 0 { 2777 errorMessage = message 2778 } 2779 2780 switch { 2781 case strings.EqualFold("InvalidNextTokenException", errorCode): 2782 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2783 2784 default: 2785 genericError := &smithy.GenericAPIError{ 2786 Code: errorCode, 2787 Message: errorMessage, 2788 } 2789 return genericError 2790 2791 } 2792} 2793 2794type awsAwsjson11_deserializeOpListForecastExportJobs struct { 2795} 2796 2797func (*awsAwsjson11_deserializeOpListForecastExportJobs) ID() string { 2798 return "OperationDeserializer" 2799} 2800 2801func (m *awsAwsjson11_deserializeOpListForecastExportJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2802 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2803) { 2804 out, metadata, err = next.HandleDeserialize(ctx, in) 2805 if err != nil { 2806 return out, metadata, err 2807 } 2808 2809 response, ok := out.RawResponse.(*smithyhttp.Response) 2810 if !ok { 2811 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2812 } 2813 2814 if response.StatusCode < 200 || response.StatusCode >= 300 { 2815 return out, metadata, awsAwsjson11_deserializeOpErrorListForecastExportJobs(response, &metadata) 2816 } 2817 output := &ListForecastExportJobsOutput{} 2818 out.Result = output 2819 2820 var buff [1024]byte 2821 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2822 2823 body := io.TeeReader(response.Body, ringBuffer) 2824 decoder := json.NewDecoder(body) 2825 decoder.UseNumber() 2826 var shape interface{} 2827 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2828 var snapshot bytes.Buffer 2829 io.Copy(&snapshot, ringBuffer) 2830 err = &smithy.DeserializationError{ 2831 Err: fmt.Errorf("failed to decode response body, %w", err), 2832 Snapshot: snapshot.Bytes(), 2833 } 2834 return out, metadata, err 2835 } 2836 2837 err = awsAwsjson11_deserializeOpDocumentListForecastExportJobsOutput(&output, shape) 2838 if err != nil { 2839 var snapshot bytes.Buffer 2840 io.Copy(&snapshot, ringBuffer) 2841 err = &smithy.DeserializationError{ 2842 Err: fmt.Errorf("failed to decode response body, %w", err), 2843 Snapshot: snapshot.Bytes(), 2844 } 2845 return out, metadata, err 2846 } 2847 2848 return out, metadata, err 2849} 2850 2851func awsAwsjson11_deserializeOpErrorListForecastExportJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2852 var errorBuffer bytes.Buffer 2853 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2854 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2855 } 2856 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2857 2858 errorCode := "UnknownError" 2859 errorMessage := errorCode 2860 2861 code := response.Header.Get("X-Amzn-ErrorType") 2862 if len(code) != 0 { 2863 errorCode = restjson.SanitizeErrorCode(code) 2864 } 2865 2866 var buff [1024]byte 2867 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2868 2869 body := io.TeeReader(errorBody, ringBuffer) 2870 decoder := json.NewDecoder(body) 2871 decoder.UseNumber() 2872 code, message, err := restjson.GetErrorInfo(decoder) 2873 if err != nil { 2874 var snapshot bytes.Buffer 2875 io.Copy(&snapshot, ringBuffer) 2876 err = &smithy.DeserializationError{ 2877 Err: fmt.Errorf("failed to decode response body, %w", err), 2878 Snapshot: snapshot.Bytes(), 2879 } 2880 return err 2881 } 2882 2883 errorBody.Seek(0, io.SeekStart) 2884 if len(code) != 0 { 2885 errorCode = restjson.SanitizeErrorCode(code) 2886 } 2887 if len(message) != 0 { 2888 errorMessage = message 2889 } 2890 2891 switch { 2892 case strings.EqualFold("InvalidInputException", errorCode): 2893 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2894 2895 case strings.EqualFold("InvalidNextTokenException", errorCode): 2896 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2897 2898 default: 2899 genericError := &smithy.GenericAPIError{ 2900 Code: errorCode, 2901 Message: errorMessage, 2902 } 2903 return genericError 2904 2905 } 2906} 2907 2908type awsAwsjson11_deserializeOpListForecasts struct { 2909} 2910 2911func (*awsAwsjson11_deserializeOpListForecasts) ID() string { 2912 return "OperationDeserializer" 2913} 2914 2915func (m *awsAwsjson11_deserializeOpListForecasts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2916 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2917) { 2918 out, metadata, err = next.HandleDeserialize(ctx, in) 2919 if err != nil { 2920 return out, metadata, err 2921 } 2922 2923 response, ok := out.RawResponse.(*smithyhttp.Response) 2924 if !ok { 2925 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2926 } 2927 2928 if response.StatusCode < 200 || response.StatusCode >= 300 { 2929 return out, metadata, awsAwsjson11_deserializeOpErrorListForecasts(response, &metadata) 2930 } 2931 output := &ListForecastsOutput{} 2932 out.Result = output 2933 2934 var buff [1024]byte 2935 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2936 2937 body := io.TeeReader(response.Body, ringBuffer) 2938 decoder := json.NewDecoder(body) 2939 decoder.UseNumber() 2940 var shape interface{} 2941 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2942 var snapshot bytes.Buffer 2943 io.Copy(&snapshot, ringBuffer) 2944 err = &smithy.DeserializationError{ 2945 Err: fmt.Errorf("failed to decode response body, %w", err), 2946 Snapshot: snapshot.Bytes(), 2947 } 2948 return out, metadata, err 2949 } 2950 2951 err = awsAwsjson11_deserializeOpDocumentListForecastsOutput(&output, shape) 2952 if err != nil { 2953 var snapshot bytes.Buffer 2954 io.Copy(&snapshot, ringBuffer) 2955 err = &smithy.DeserializationError{ 2956 Err: fmt.Errorf("failed to decode response body, %w", err), 2957 Snapshot: snapshot.Bytes(), 2958 } 2959 return out, metadata, err 2960 } 2961 2962 return out, metadata, err 2963} 2964 2965func awsAwsjson11_deserializeOpErrorListForecasts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2966 var errorBuffer bytes.Buffer 2967 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2968 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2969 } 2970 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2971 2972 errorCode := "UnknownError" 2973 errorMessage := errorCode 2974 2975 code := response.Header.Get("X-Amzn-ErrorType") 2976 if len(code) != 0 { 2977 errorCode = restjson.SanitizeErrorCode(code) 2978 } 2979 2980 var buff [1024]byte 2981 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2982 2983 body := io.TeeReader(errorBody, ringBuffer) 2984 decoder := json.NewDecoder(body) 2985 decoder.UseNumber() 2986 code, message, err := restjson.GetErrorInfo(decoder) 2987 if err != nil { 2988 var snapshot bytes.Buffer 2989 io.Copy(&snapshot, ringBuffer) 2990 err = &smithy.DeserializationError{ 2991 Err: fmt.Errorf("failed to decode response body, %w", err), 2992 Snapshot: snapshot.Bytes(), 2993 } 2994 return err 2995 } 2996 2997 errorBody.Seek(0, io.SeekStart) 2998 if len(code) != 0 { 2999 errorCode = restjson.SanitizeErrorCode(code) 3000 } 3001 if len(message) != 0 { 3002 errorMessage = message 3003 } 3004 3005 switch { 3006 case strings.EqualFold("InvalidInputException", errorCode): 3007 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3008 3009 case strings.EqualFold("InvalidNextTokenException", errorCode): 3010 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3011 3012 default: 3013 genericError := &smithy.GenericAPIError{ 3014 Code: errorCode, 3015 Message: errorMessage, 3016 } 3017 return genericError 3018 3019 } 3020} 3021 3022type awsAwsjson11_deserializeOpListPredictorBacktestExportJobs struct { 3023} 3024 3025func (*awsAwsjson11_deserializeOpListPredictorBacktestExportJobs) ID() string { 3026 return "OperationDeserializer" 3027} 3028 3029func (m *awsAwsjson11_deserializeOpListPredictorBacktestExportJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3030 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3031) { 3032 out, metadata, err = next.HandleDeserialize(ctx, in) 3033 if err != nil { 3034 return out, metadata, err 3035 } 3036 3037 response, ok := out.RawResponse.(*smithyhttp.Response) 3038 if !ok { 3039 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3040 } 3041 3042 if response.StatusCode < 200 || response.StatusCode >= 300 { 3043 return out, metadata, awsAwsjson11_deserializeOpErrorListPredictorBacktestExportJobs(response, &metadata) 3044 } 3045 output := &ListPredictorBacktestExportJobsOutput{} 3046 out.Result = output 3047 3048 var buff [1024]byte 3049 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3050 3051 body := io.TeeReader(response.Body, ringBuffer) 3052 decoder := json.NewDecoder(body) 3053 decoder.UseNumber() 3054 var shape interface{} 3055 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3056 var snapshot bytes.Buffer 3057 io.Copy(&snapshot, ringBuffer) 3058 err = &smithy.DeserializationError{ 3059 Err: fmt.Errorf("failed to decode response body, %w", err), 3060 Snapshot: snapshot.Bytes(), 3061 } 3062 return out, metadata, err 3063 } 3064 3065 err = awsAwsjson11_deserializeOpDocumentListPredictorBacktestExportJobsOutput(&output, shape) 3066 if err != nil { 3067 var snapshot bytes.Buffer 3068 io.Copy(&snapshot, ringBuffer) 3069 err = &smithy.DeserializationError{ 3070 Err: fmt.Errorf("failed to decode response body, %w", err), 3071 Snapshot: snapshot.Bytes(), 3072 } 3073 return out, metadata, err 3074 } 3075 3076 return out, metadata, err 3077} 3078 3079func awsAwsjson11_deserializeOpErrorListPredictorBacktestExportJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3080 var errorBuffer bytes.Buffer 3081 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3082 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3083 } 3084 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3085 3086 errorCode := "UnknownError" 3087 errorMessage := errorCode 3088 3089 code := response.Header.Get("X-Amzn-ErrorType") 3090 if len(code) != 0 { 3091 errorCode = restjson.SanitizeErrorCode(code) 3092 } 3093 3094 var buff [1024]byte 3095 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3096 3097 body := io.TeeReader(errorBody, ringBuffer) 3098 decoder := json.NewDecoder(body) 3099 decoder.UseNumber() 3100 code, message, err := restjson.GetErrorInfo(decoder) 3101 if err != nil { 3102 var snapshot bytes.Buffer 3103 io.Copy(&snapshot, ringBuffer) 3104 err = &smithy.DeserializationError{ 3105 Err: fmt.Errorf("failed to decode response body, %w", err), 3106 Snapshot: snapshot.Bytes(), 3107 } 3108 return err 3109 } 3110 3111 errorBody.Seek(0, io.SeekStart) 3112 if len(code) != 0 { 3113 errorCode = restjson.SanitizeErrorCode(code) 3114 } 3115 if len(message) != 0 { 3116 errorMessage = message 3117 } 3118 3119 switch { 3120 case strings.EqualFold("InvalidInputException", errorCode): 3121 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3122 3123 case strings.EqualFold("InvalidNextTokenException", errorCode): 3124 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3125 3126 default: 3127 genericError := &smithy.GenericAPIError{ 3128 Code: errorCode, 3129 Message: errorMessage, 3130 } 3131 return genericError 3132 3133 } 3134} 3135 3136type awsAwsjson11_deserializeOpListPredictors struct { 3137} 3138 3139func (*awsAwsjson11_deserializeOpListPredictors) ID() string { 3140 return "OperationDeserializer" 3141} 3142 3143func (m *awsAwsjson11_deserializeOpListPredictors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3144 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3145) { 3146 out, metadata, err = next.HandleDeserialize(ctx, in) 3147 if err != nil { 3148 return out, metadata, err 3149 } 3150 3151 response, ok := out.RawResponse.(*smithyhttp.Response) 3152 if !ok { 3153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3154 } 3155 3156 if response.StatusCode < 200 || response.StatusCode >= 300 { 3157 return out, metadata, awsAwsjson11_deserializeOpErrorListPredictors(response, &metadata) 3158 } 3159 output := &ListPredictorsOutput{} 3160 out.Result = output 3161 3162 var buff [1024]byte 3163 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3164 3165 body := io.TeeReader(response.Body, ringBuffer) 3166 decoder := json.NewDecoder(body) 3167 decoder.UseNumber() 3168 var shape interface{} 3169 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3170 var snapshot bytes.Buffer 3171 io.Copy(&snapshot, ringBuffer) 3172 err = &smithy.DeserializationError{ 3173 Err: fmt.Errorf("failed to decode response body, %w", err), 3174 Snapshot: snapshot.Bytes(), 3175 } 3176 return out, metadata, err 3177 } 3178 3179 err = awsAwsjson11_deserializeOpDocumentListPredictorsOutput(&output, shape) 3180 if err != nil { 3181 var snapshot bytes.Buffer 3182 io.Copy(&snapshot, ringBuffer) 3183 err = &smithy.DeserializationError{ 3184 Err: fmt.Errorf("failed to decode response body, %w", err), 3185 Snapshot: snapshot.Bytes(), 3186 } 3187 return out, metadata, err 3188 } 3189 3190 return out, metadata, err 3191} 3192 3193func awsAwsjson11_deserializeOpErrorListPredictors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3194 var errorBuffer bytes.Buffer 3195 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3196 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3197 } 3198 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3199 3200 errorCode := "UnknownError" 3201 errorMessage := errorCode 3202 3203 code := response.Header.Get("X-Amzn-ErrorType") 3204 if len(code) != 0 { 3205 errorCode = restjson.SanitizeErrorCode(code) 3206 } 3207 3208 var buff [1024]byte 3209 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3210 3211 body := io.TeeReader(errorBody, ringBuffer) 3212 decoder := json.NewDecoder(body) 3213 decoder.UseNumber() 3214 code, message, err := restjson.GetErrorInfo(decoder) 3215 if err != nil { 3216 var snapshot bytes.Buffer 3217 io.Copy(&snapshot, ringBuffer) 3218 err = &smithy.DeserializationError{ 3219 Err: fmt.Errorf("failed to decode response body, %w", err), 3220 Snapshot: snapshot.Bytes(), 3221 } 3222 return err 3223 } 3224 3225 errorBody.Seek(0, io.SeekStart) 3226 if len(code) != 0 { 3227 errorCode = restjson.SanitizeErrorCode(code) 3228 } 3229 if len(message) != 0 { 3230 errorMessage = message 3231 } 3232 3233 switch { 3234 case strings.EqualFold("InvalidInputException", errorCode): 3235 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3236 3237 case strings.EqualFold("InvalidNextTokenException", errorCode): 3238 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3239 3240 default: 3241 genericError := &smithy.GenericAPIError{ 3242 Code: errorCode, 3243 Message: errorMessage, 3244 } 3245 return genericError 3246 3247 } 3248} 3249 3250type awsAwsjson11_deserializeOpListTagsForResource struct { 3251} 3252 3253func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 3254 return "OperationDeserializer" 3255} 3256 3257func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3258 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3259) { 3260 out, metadata, err = next.HandleDeserialize(ctx, in) 3261 if err != nil { 3262 return out, metadata, err 3263 } 3264 3265 response, ok := out.RawResponse.(*smithyhttp.Response) 3266 if !ok { 3267 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3268 } 3269 3270 if response.StatusCode < 200 || response.StatusCode >= 300 { 3271 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 3272 } 3273 output := &ListTagsForResourceOutput{} 3274 out.Result = output 3275 3276 var buff [1024]byte 3277 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3278 3279 body := io.TeeReader(response.Body, ringBuffer) 3280 decoder := json.NewDecoder(body) 3281 decoder.UseNumber() 3282 var shape interface{} 3283 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3284 var snapshot bytes.Buffer 3285 io.Copy(&snapshot, ringBuffer) 3286 err = &smithy.DeserializationError{ 3287 Err: fmt.Errorf("failed to decode response body, %w", err), 3288 Snapshot: snapshot.Bytes(), 3289 } 3290 return out, metadata, err 3291 } 3292 3293 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 3294 if err != nil { 3295 var snapshot bytes.Buffer 3296 io.Copy(&snapshot, ringBuffer) 3297 err = &smithy.DeserializationError{ 3298 Err: fmt.Errorf("failed to decode response body, %w", err), 3299 Snapshot: snapshot.Bytes(), 3300 } 3301 return out, metadata, err 3302 } 3303 3304 return out, metadata, err 3305} 3306 3307func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3308 var errorBuffer bytes.Buffer 3309 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3310 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3311 } 3312 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3313 3314 errorCode := "UnknownError" 3315 errorMessage := errorCode 3316 3317 code := response.Header.Get("X-Amzn-ErrorType") 3318 if len(code) != 0 { 3319 errorCode = restjson.SanitizeErrorCode(code) 3320 } 3321 3322 var buff [1024]byte 3323 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3324 3325 body := io.TeeReader(errorBody, ringBuffer) 3326 decoder := json.NewDecoder(body) 3327 decoder.UseNumber() 3328 code, message, err := restjson.GetErrorInfo(decoder) 3329 if err != nil { 3330 var snapshot bytes.Buffer 3331 io.Copy(&snapshot, ringBuffer) 3332 err = &smithy.DeserializationError{ 3333 Err: fmt.Errorf("failed to decode response body, %w", err), 3334 Snapshot: snapshot.Bytes(), 3335 } 3336 return err 3337 } 3338 3339 errorBody.Seek(0, io.SeekStart) 3340 if len(code) != 0 { 3341 errorCode = restjson.SanitizeErrorCode(code) 3342 } 3343 if len(message) != 0 { 3344 errorMessage = message 3345 } 3346 3347 switch { 3348 case strings.EqualFold("InvalidInputException", errorCode): 3349 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3350 3351 case strings.EqualFold("ResourceNotFoundException", errorCode): 3352 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3353 3354 default: 3355 genericError := &smithy.GenericAPIError{ 3356 Code: errorCode, 3357 Message: errorMessage, 3358 } 3359 return genericError 3360 3361 } 3362} 3363 3364type awsAwsjson11_deserializeOpTagResource struct { 3365} 3366 3367func (*awsAwsjson11_deserializeOpTagResource) ID() string { 3368 return "OperationDeserializer" 3369} 3370 3371func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3372 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3373) { 3374 out, metadata, err = next.HandleDeserialize(ctx, in) 3375 if err != nil { 3376 return out, metadata, err 3377 } 3378 3379 response, ok := out.RawResponse.(*smithyhttp.Response) 3380 if !ok { 3381 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3382 } 3383 3384 if response.StatusCode < 200 || response.StatusCode >= 300 { 3385 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 3386 } 3387 output := &TagResourceOutput{} 3388 out.Result = output 3389 3390 var buff [1024]byte 3391 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3392 3393 body := io.TeeReader(response.Body, ringBuffer) 3394 decoder := json.NewDecoder(body) 3395 decoder.UseNumber() 3396 var shape interface{} 3397 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3398 var snapshot bytes.Buffer 3399 io.Copy(&snapshot, ringBuffer) 3400 err = &smithy.DeserializationError{ 3401 Err: fmt.Errorf("failed to decode response body, %w", err), 3402 Snapshot: snapshot.Bytes(), 3403 } 3404 return out, metadata, err 3405 } 3406 3407 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 3408 if err != nil { 3409 var snapshot bytes.Buffer 3410 io.Copy(&snapshot, ringBuffer) 3411 err = &smithy.DeserializationError{ 3412 Err: fmt.Errorf("failed to decode response body, %w", err), 3413 Snapshot: snapshot.Bytes(), 3414 } 3415 return out, metadata, err 3416 } 3417 3418 return out, metadata, err 3419} 3420 3421func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3422 var errorBuffer bytes.Buffer 3423 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3424 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3425 } 3426 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3427 3428 errorCode := "UnknownError" 3429 errorMessage := errorCode 3430 3431 code := response.Header.Get("X-Amzn-ErrorType") 3432 if len(code) != 0 { 3433 errorCode = restjson.SanitizeErrorCode(code) 3434 } 3435 3436 var buff [1024]byte 3437 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3438 3439 body := io.TeeReader(errorBody, ringBuffer) 3440 decoder := json.NewDecoder(body) 3441 decoder.UseNumber() 3442 code, message, err := restjson.GetErrorInfo(decoder) 3443 if err != nil { 3444 var snapshot bytes.Buffer 3445 io.Copy(&snapshot, ringBuffer) 3446 err = &smithy.DeserializationError{ 3447 Err: fmt.Errorf("failed to decode response body, %w", err), 3448 Snapshot: snapshot.Bytes(), 3449 } 3450 return err 3451 } 3452 3453 errorBody.Seek(0, io.SeekStart) 3454 if len(code) != 0 { 3455 errorCode = restjson.SanitizeErrorCode(code) 3456 } 3457 if len(message) != 0 { 3458 errorMessage = message 3459 } 3460 3461 switch { 3462 case strings.EqualFold("InvalidInputException", errorCode): 3463 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3464 3465 case strings.EqualFold("LimitExceededException", errorCode): 3466 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 3467 3468 case strings.EqualFold("ResourceNotFoundException", errorCode): 3469 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3470 3471 default: 3472 genericError := &smithy.GenericAPIError{ 3473 Code: errorCode, 3474 Message: errorMessage, 3475 } 3476 return genericError 3477 3478 } 3479} 3480 3481type awsAwsjson11_deserializeOpUntagResource struct { 3482} 3483 3484func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 3485 return "OperationDeserializer" 3486} 3487 3488func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3489 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3490) { 3491 out, metadata, err = next.HandleDeserialize(ctx, in) 3492 if err != nil { 3493 return out, metadata, err 3494 } 3495 3496 response, ok := out.RawResponse.(*smithyhttp.Response) 3497 if !ok { 3498 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3499 } 3500 3501 if response.StatusCode < 200 || response.StatusCode >= 300 { 3502 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 3503 } 3504 output := &UntagResourceOutput{} 3505 out.Result = output 3506 3507 var buff [1024]byte 3508 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3509 3510 body := io.TeeReader(response.Body, ringBuffer) 3511 decoder := json.NewDecoder(body) 3512 decoder.UseNumber() 3513 var shape interface{} 3514 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3515 var snapshot bytes.Buffer 3516 io.Copy(&snapshot, ringBuffer) 3517 err = &smithy.DeserializationError{ 3518 Err: fmt.Errorf("failed to decode response body, %w", err), 3519 Snapshot: snapshot.Bytes(), 3520 } 3521 return out, metadata, err 3522 } 3523 3524 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 3525 if err != nil { 3526 var snapshot bytes.Buffer 3527 io.Copy(&snapshot, ringBuffer) 3528 err = &smithy.DeserializationError{ 3529 Err: fmt.Errorf("failed to decode response body, %w", err), 3530 Snapshot: snapshot.Bytes(), 3531 } 3532 return out, metadata, err 3533 } 3534 3535 return out, metadata, err 3536} 3537 3538func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3539 var errorBuffer bytes.Buffer 3540 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3541 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3542 } 3543 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3544 3545 errorCode := "UnknownError" 3546 errorMessage := errorCode 3547 3548 code := response.Header.Get("X-Amzn-ErrorType") 3549 if len(code) != 0 { 3550 errorCode = restjson.SanitizeErrorCode(code) 3551 } 3552 3553 var buff [1024]byte 3554 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3555 3556 body := io.TeeReader(errorBody, ringBuffer) 3557 decoder := json.NewDecoder(body) 3558 decoder.UseNumber() 3559 code, message, err := restjson.GetErrorInfo(decoder) 3560 if err != nil { 3561 var snapshot bytes.Buffer 3562 io.Copy(&snapshot, ringBuffer) 3563 err = &smithy.DeserializationError{ 3564 Err: fmt.Errorf("failed to decode response body, %w", err), 3565 Snapshot: snapshot.Bytes(), 3566 } 3567 return err 3568 } 3569 3570 errorBody.Seek(0, io.SeekStart) 3571 if len(code) != 0 { 3572 errorCode = restjson.SanitizeErrorCode(code) 3573 } 3574 if len(message) != 0 { 3575 errorMessage = message 3576 } 3577 3578 switch { 3579 case strings.EqualFold("InvalidInputException", errorCode): 3580 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3581 3582 case strings.EqualFold("ResourceNotFoundException", errorCode): 3583 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3584 3585 default: 3586 genericError := &smithy.GenericAPIError{ 3587 Code: errorCode, 3588 Message: errorMessage, 3589 } 3590 return genericError 3591 3592 } 3593} 3594 3595type awsAwsjson11_deserializeOpUpdateDatasetGroup struct { 3596} 3597 3598func (*awsAwsjson11_deserializeOpUpdateDatasetGroup) ID() string { 3599 return "OperationDeserializer" 3600} 3601 3602func (m *awsAwsjson11_deserializeOpUpdateDatasetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3603 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3604) { 3605 out, metadata, err = next.HandleDeserialize(ctx, in) 3606 if err != nil { 3607 return out, metadata, err 3608 } 3609 3610 response, ok := out.RawResponse.(*smithyhttp.Response) 3611 if !ok { 3612 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3613 } 3614 3615 if response.StatusCode < 200 || response.StatusCode >= 300 { 3616 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDatasetGroup(response, &metadata) 3617 } 3618 output := &UpdateDatasetGroupOutput{} 3619 out.Result = output 3620 3621 var buff [1024]byte 3622 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3623 3624 body := io.TeeReader(response.Body, ringBuffer) 3625 decoder := json.NewDecoder(body) 3626 decoder.UseNumber() 3627 var shape interface{} 3628 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3629 var snapshot bytes.Buffer 3630 io.Copy(&snapshot, ringBuffer) 3631 err = &smithy.DeserializationError{ 3632 Err: fmt.Errorf("failed to decode response body, %w", err), 3633 Snapshot: snapshot.Bytes(), 3634 } 3635 return out, metadata, err 3636 } 3637 3638 err = awsAwsjson11_deserializeOpDocumentUpdateDatasetGroupOutput(&output, shape) 3639 if err != nil { 3640 var snapshot bytes.Buffer 3641 io.Copy(&snapshot, ringBuffer) 3642 err = &smithy.DeserializationError{ 3643 Err: fmt.Errorf("failed to decode response body, %w", err), 3644 Snapshot: snapshot.Bytes(), 3645 } 3646 return out, metadata, err 3647 } 3648 3649 return out, metadata, err 3650} 3651 3652func awsAwsjson11_deserializeOpErrorUpdateDatasetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3653 var errorBuffer bytes.Buffer 3654 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3655 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3656 } 3657 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3658 3659 errorCode := "UnknownError" 3660 errorMessage := errorCode 3661 3662 code := response.Header.Get("X-Amzn-ErrorType") 3663 if len(code) != 0 { 3664 errorCode = restjson.SanitizeErrorCode(code) 3665 } 3666 3667 var buff [1024]byte 3668 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3669 3670 body := io.TeeReader(errorBody, ringBuffer) 3671 decoder := json.NewDecoder(body) 3672 decoder.UseNumber() 3673 code, message, err := restjson.GetErrorInfo(decoder) 3674 if err != nil { 3675 var snapshot bytes.Buffer 3676 io.Copy(&snapshot, ringBuffer) 3677 err = &smithy.DeserializationError{ 3678 Err: fmt.Errorf("failed to decode response body, %w", err), 3679 Snapshot: snapshot.Bytes(), 3680 } 3681 return err 3682 } 3683 3684 errorBody.Seek(0, io.SeekStart) 3685 if len(code) != 0 { 3686 errorCode = restjson.SanitizeErrorCode(code) 3687 } 3688 if len(message) != 0 { 3689 errorMessage = message 3690 } 3691 3692 switch { 3693 case strings.EqualFold("InvalidInputException", errorCode): 3694 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3695 3696 case strings.EqualFold("ResourceInUseException", errorCode): 3697 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 3698 3699 case strings.EqualFold("ResourceNotFoundException", errorCode): 3700 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3701 3702 default: 3703 genericError := &smithy.GenericAPIError{ 3704 Code: errorCode, 3705 Message: errorMessage, 3706 } 3707 return genericError 3708 3709 } 3710} 3711 3712func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3713 var buff [1024]byte 3714 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3715 3716 body := io.TeeReader(errorBody, ringBuffer) 3717 decoder := json.NewDecoder(body) 3718 decoder.UseNumber() 3719 var shape interface{} 3720 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3721 var snapshot bytes.Buffer 3722 io.Copy(&snapshot, ringBuffer) 3723 err = &smithy.DeserializationError{ 3724 Err: fmt.Errorf("failed to decode response body, %w", err), 3725 Snapshot: snapshot.Bytes(), 3726 } 3727 return err 3728 } 3729 3730 output := &types.InvalidInputException{} 3731 err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape) 3732 3733 if err != nil { 3734 var snapshot bytes.Buffer 3735 io.Copy(&snapshot, ringBuffer) 3736 err = &smithy.DeserializationError{ 3737 Err: fmt.Errorf("failed to decode response body, %w", err), 3738 Snapshot: snapshot.Bytes(), 3739 } 3740 return err 3741 } 3742 3743 errorBody.Seek(0, io.SeekStart) 3744 return output 3745} 3746 3747func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3748 var buff [1024]byte 3749 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3750 3751 body := io.TeeReader(errorBody, ringBuffer) 3752 decoder := json.NewDecoder(body) 3753 decoder.UseNumber() 3754 var shape interface{} 3755 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3756 var snapshot bytes.Buffer 3757 io.Copy(&snapshot, ringBuffer) 3758 err = &smithy.DeserializationError{ 3759 Err: fmt.Errorf("failed to decode response body, %w", err), 3760 Snapshot: snapshot.Bytes(), 3761 } 3762 return err 3763 } 3764 3765 output := &types.InvalidNextTokenException{} 3766 err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape) 3767 3768 if err != nil { 3769 var snapshot bytes.Buffer 3770 io.Copy(&snapshot, ringBuffer) 3771 err = &smithy.DeserializationError{ 3772 Err: fmt.Errorf("failed to decode response body, %w", err), 3773 Snapshot: snapshot.Bytes(), 3774 } 3775 return err 3776 } 3777 3778 errorBody.Seek(0, io.SeekStart) 3779 return output 3780} 3781 3782func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3783 var buff [1024]byte 3784 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3785 3786 body := io.TeeReader(errorBody, ringBuffer) 3787 decoder := json.NewDecoder(body) 3788 decoder.UseNumber() 3789 var shape interface{} 3790 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3791 var snapshot bytes.Buffer 3792 io.Copy(&snapshot, ringBuffer) 3793 err = &smithy.DeserializationError{ 3794 Err: fmt.Errorf("failed to decode response body, %w", err), 3795 Snapshot: snapshot.Bytes(), 3796 } 3797 return err 3798 } 3799 3800 output := &types.LimitExceededException{} 3801 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 3802 3803 if err != nil { 3804 var snapshot bytes.Buffer 3805 io.Copy(&snapshot, ringBuffer) 3806 err = &smithy.DeserializationError{ 3807 Err: fmt.Errorf("failed to decode response body, %w", err), 3808 Snapshot: snapshot.Bytes(), 3809 } 3810 return err 3811 } 3812 3813 errorBody.Seek(0, io.SeekStart) 3814 return output 3815} 3816 3817func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3818 var buff [1024]byte 3819 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3820 3821 body := io.TeeReader(errorBody, ringBuffer) 3822 decoder := json.NewDecoder(body) 3823 decoder.UseNumber() 3824 var shape interface{} 3825 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3826 var snapshot bytes.Buffer 3827 io.Copy(&snapshot, ringBuffer) 3828 err = &smithy.DeserializationError{ 3829 Err: fmt.Errorf("failed to decode response body, %w", err), 3830 Snapshot: snapshot.Bytes(), 3831 } 3832 return err 3833 } 3834 3835 output := &types.ResourceAlreadyExistsException{} 3836 err := awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(&output, shape) 3837 3838 if err != nil { 3839 var snapshot bytes.Buffer 3840 io.Copy(&snapshot, ringBuffer) 3841 err = &smithy.DeserializationError{ 3842 Err: fmt.Errorf("failed to decode response body, %w", err), 3843 Snapshot: snapshot.Bytes(), 3844 } 3845 return err 3846 } 3847 3848 errorBody.Seek(0, io.SeekStart) 3849 return output 3850} 3851 3852func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3853 var buff [1024]byte 3854 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3855 3856 body := io.TeeReader(errorBody, ringBuffer) 3857 decoder := json.NewDecoder(body) 3858 decoder.UseNumber() 3859 var shape interface{} 3860 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3861 var snapshot bytes.Buffer 3862 io.Copy(&snapshot, ringBuffer) 3863 err = &smithy.DeserializationError{ 3864 Err: fmt.Errorf("failed to decode response body, %w", err), 3865 Snapshot: snapshot.Bytes(), 3866 } 3867 return err 3868 } 3869 3870 output := &types.ResourceInUseException{} 3871 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 3872 3873 if err != nil { 3874 var snapshot bytes.Buffer 3875 io.Copy(&snapshot, ringBuffer) 3876 err = &smithy.DeserializationError{ 3877 Err: fmt.Errorf("failed to decode response body, %w", err), 3878 Snapshot: snapshot.Bytes(), 3879 } 3880 return err 3881 } 3882 3883 errorBody.Seek(0, io.SeekStart) 3884 return output 3885} 3886 3887func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3888 var buff [1024]byte 3889 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3890 3891 body := io.TeeReader(errorBody, ringBuffer) 3892 decoder := json.NewDecoder(body) 3893 decoder.UseNumber() 3894 var shape interface{} 3895 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3896 var snapshot bytes.Buffer 3897 io.Copy(&snapshot, ringBuffer) 3898 err = &smithy.DeserializationError{ 3899 Err: fmt.Errorf("failed to decode response body, %w", err), 3900 Snapshot: snapshot.Bytes(), 3901 } 3902 return err 3903 } 3904 3905 output := &types.ResourceNotFoundException{} 3906 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 3907 3908 if err != nil { 3909 var snapshot bytes.Buffer 3910 io.Copy(&snapshot, ringBuffer) 3911 err = &smithy.DeserializationError{ 3912 Err: fmt.Errorf("failed to decode response body, %w", err), 3913 Snapshot: snapshot.Bytes(), 3914 } 3915 return err 3916 } 3917 3918 errorBody.Seek(0, io.SeekStart) 3919 return output 3920} 3921 3922func awsAwsjson11_deserializeDocumentArnList(v *[]string, value interface{}) error { 3923 if v == nil { 3924 return fmt.Errorf("unexpected nil of type %T", v) 3925 } 3926 if value == nil { 3927 return nil 3928 } 3929 3930 shape, ok := value.([]interface{}) 3931 if !ok { 3932 return fmt.Errorf("unexpected JSON type %v", value) 3933 } 3934 3935 var cv []string 3936 if *v == nil { 3937 cv = []string{} 3938 } else { 3939 cv = *v 3940 } 3941 3942 for _, value := range shape { 3943 var col string 3944 if value != nil { 3945 jtv, ok := value.(string) 3946 if !ok { 3947 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3948 } 3949 col = jtv 3950 } 3951 cv = append(cv, col) 3952 3953 } 3954 *v = cv 3955 return nil 3956} 3957 3958func awsAwsjson11_deserializeDocumentCategoricalParameterRange(v **types.CategoricalParameterRange, value interface{}) error { 3959 if v == nil { 3960 return fmt.Errorf("unexpected nil of type %T", v) 3961 } 3962 if value == nil { 3963 return nil 3964 } 3965 3966 shape, ok := value.(map[string]interface{}) 3967 if !ok { 3968 return fmt.Errorf("unexpected JSON type %v", value) 3969 } 3970 3971 var sv *types.CategoricalParameterRange 3972 if *v == nil { 3973 sv = &types.CategoricalParameterRange{} 3974 } else { 3975 sv = *v 3976 } 3977 3978 for key, value := range shape { 3979 switch key { 3980 case "Name": 3981 if value != nil { 3982 jtv, ok := value.(string) 3983 if !ok { 3984 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 3985 } 3986 sv.Name = ptr.String(jtv) 3987 } 3988 3989 case "Values": 3990 if err := awsAwsjson11_deserializeDocumentValues(&sv.Values, value); err != nil { 3991 return err 3992 } 3993 3994 default: 3995 _, _ = key, value 3996 3997 } 3998 } 3999 *v = sv 4000 return nil 4001} 4002 4003func awsAwsjson11_deserializeDocumentCategoricalParameterRanges(v *[]types.CategoricalParameterRange, value interface{}) error { 4004 if v == nil { 4005 return fmt.Errorf("unexpected nil of type %T", v) 4006 } 4007 if value == nil { 4008 return nil 4009 } 4010 4011 shape, ok := value.([]interface{}) 4012 if !ok { 4013 return fmt.Errorf("unexpected JSON type %v", value) 4014 } 4015 4016 var cv []types.CategoricalParameterRange 4017 if *v == nil { 4018 cv = []types.CategoricalParameterRange{} 4019 } else { 4020 cv = *v 4021 } 4022 4023 for _, value := range shape { 4024 var col types.CategoricalParameterRange 4025 destAddr := &col 4026 if err := awsAwsjson11_deserializeDocumentCategoricalParameterRange(&destAddr, value); err != nil { 4027 return err 4028 } 4029 col = *destAddr 4030 cv = append(cv, col) 4031 4032 } 4033 *v = cv 4034 return nil 4035} 4036 4037func awsAwsjson11_deserializeDocumentContinuousParameterRange(v **types.ContinuousParameterRange, value interface{}) error { 4038 if v == nil { 4039 return fmt.Errorf("unexpected nil of type %T", v) 4040 } 4041 if value == nil { 4042 return nil 4043 } 4044 4045 shape, ok := value.(map[string]interface{}) 4046 if !ok { 4047 return fmt.Errorf("unexpected JSON type %v", value) 4048 } 4049 4050 var sv *types.ContinuousParameterRange 4051 if *v == nil { 4052 sv = &types.ContinuousParameterRange{} 4053 } else { 4054 sv = *v 4055 } 4056 4057 for key, value := range shape { 4058 switch key { 4059 case "MaxValue": 4060 if value != nil { 4061 jtv, ok := value.(json.Number) 4062 if !ok { 4063 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 4064 } 4065 f64, err := jtv.Float64() 4066 if err != nil { 4067 return err 4068 } 4069 sv.MaxValue = ptr.Float64(f64) 4070 } 4071 4072 case "MinValue": 4073 if value != nil { 4074 jtv, ok := value.(json.Number) 4075 if !ok { 4076 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 4077 } 4078 f64, err := jtv.Float64() 4079 if err != nil { 4080 return err 4081 } 4082 sv.MinValue = ptr.Float64(f64) 4083 } 4084 4085 case "Name": 4086 if value != nil { 4087 jtv, ok := value.(string) 4088 if !ok { 4089 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 4090 } 4091 sv.Name = ptr.String(jtv) 4092 } 4093 4094 case "ScalingType": 4095 if value != nil { 4096 jtv, ok := value.(string) 4097 if !ok { 4098 return fmt.Errorf("expected ScalingType to be of type string, got %T instead", value) 4099 } 4100 sv.ScalingType = types.ScalingType(jtv) 4101 } 4102 4103 default: 4104 _, _ = key, value 4105 4106 } 4107 } 4108 *v = sv 4109 return nil 4110} 4111 4112func awsAwsjson11_deserializeDocumentContinuousParameterRanges(v *[]types.ContinuousParameterRange, value interface{}) error { 4113 if v == nil { 4114 return fmt.Errorf("unexpected nil of type %T", v) 4115 } 4116 if value == nil { 4117 return nil 4118 } 4119 4120 shape, ok := value.([]interface{}) 4121 if !ok { 4122 return fmt.Errorf("unexpected JSON type %v", value) 4123 } 4124 4125 var cv []types.ContinuousParameterRange 4126 if *v == nil { 4127 cv = []types.ContinuousParameterRange{} 4128 } else { 4129 cv = *v 4130 } 4131 4132 for _, value := range shape { 4133 var col types.ContinuousParameterRange 4134 destAddr := &col 4135 if err := awsAwsjson11_deserializeDocumentContinuousParameterRange(&destAddr, value); err != nil { 4136 return err 4137 } 4138 col = *destAddr 4139 cv = append(cv, col) 4140 4141 } 4142 *v = cv 4143 return nil 4144} 4145 4146func awsAwsjson11_deserializeDocumentDataDestination(v **types.DataDestination, value interface{}) error { 4147 if v == nil { 4148 return fmt.Errorf("unexpected nil of type %T", v) 4149 } 4150 if value == nil { 4151 return nil 4152 } 4153 4154 shape, ok := value.(map[string]interface{}) 4155 if !ok { 4156 return fmt.Errorf("unexpected JSON type %v", value) 4157 } 4158 4159 var sv *types.DataDestination 4160 if *v == nil { 4161 sv = &types.DataDestination{} 4162 } else { 4163 sv = *v 4164 } 4165 4166 for key, value := range shape { 4167 switch key { 4168 case "S3Config": 4169 if err := awsAwsjson11_deserializeDocumentS3Config(&sv.S3Config, value); err != nil { 4170 return err 4171 } 4172 4173 default: 4174 _, _ = key, value 4175 4176 } 4177 } 4178 *v = sv 4179 return nil 4180} 4181 4182func awsAwsjson11_deserializeDocumentDatasetGroups(v *[]types.DatasetGroupSummary, value interface{}) error { 4183 if v == nil { 4184 return fmt.Errorf("unexpected nil of type %T", v) 4185 } 4186 if value == nil { 4187 return nil 4188 } 4189 4190 shape, ok := value.([]interface{}) 4191 if !ok { 4192 return fmt.Errorf("unexpected JSON type %v", value) 4193 } 4194 4195 var cv []types.DatasetGroupSummary 4196 if *v == nil { 4197 cv = []types.DatasetGroupSummary{} 4198 } else { 4199 cv = *v 4200 } 4201 4202 for _, value := range shape { 4203 var col types.DatasetGroupSummary 4204 destAddr := &col 4205 if err := awsAwsjson11_deserializeDocumentDatasetGroupSummary(&destAddr, value); err != nil { 4206 return err 4207 } 4208 col = *destAddr 4209 cv = append(cv, col) 4210 4211 } 4212 *v = cv 4213 return nil 4214} 4215 4216func awsAwsjson11_deserializeDocumentDatasetGroupSummary(v **types.DatasetGroupSummary, value interface{}) error { 4217 if v == nil { 4218 return fmt.Errorf("unexpected nil of type %T", v) 4219 } 4220 if value == nil { 4221 return nil 4222 } 4223 4224 shape, ok := value.(map[string]interface{}) 4225 if !ok { 4226 return fmt.Errorf("unexpected JSON type %v", value) 4227 } 4228 4229 var sv *types.DatasetGroupSummary 4230 if *v == nil { 4231 sv = &types.DatasetGroupSummary{} 4232 } else { 4233 sv = *v 4234 } 4235 4236 for key, value := range shape { 4237 switch key { 4238 case "CreationTime": 4239 if value != nil { 4240 jtv, ok := value.(json.Number) 4241 if !ok { 4242 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4243 } 4244 f64, err := jtv.Float64() 4245 if err != nil { 4246 return err 4247 } 4248 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4249 } 4250 4251 case "DatasetGroupArn": 4252 if value != nil { 4253 jtv, ok := value.(string) 4254 if !ok { 4255 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4256 } 4257 sv.DatasetGroupArn = ptr.String(jtv) 4258 } 4259 4260 case "DatasetGroupName": 4261 if value != nil { 4262 jtv, ok := value.(string) 4263 if !ok { 4264 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 4265 } 4266 sv.DatasetGroupName = ptr.String(jtv) 4267 } 4268 4269 case "LastModificationTime": 4270 if value != nil { 4271 jtv, ok := value.(json.Number) 4272 if !ok { 4273 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4274 } 4275 f64, err := jtv.Float64() 4276 if err != nil { 4277 return err 4278 } 4279 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4280 } 4281 4282 default: 4283 _, _ = key, value 4284 4285 } 4286 } 4287 *v = sv 4288 return nil 4289} 4290 4291func awsAwsjson11_deserializeDocumentDatasetImportJobs(v *[]types.DatasetImportJobSummary, value interface{}) error { 4292 if v == nil { 4293 return fmt.Errorf("unexpected nil of type %T", v) 4294 } 4295 if value == nil { 4296 return nil 4297 } 4298 4299 shape, ok := value.([]interface{}) 4300 if !ok { 4301 return fmt.Errorf("unexpected JSON type %v", value) 4302 } 4303 4304 var cv []types.DatasetImportJobSummary 4305 if *v == nil { 4306 cv = []types.DatasetImportJobSummary{} 4307 } else { 4308 cv = *v 4309 } 4310 4311 for _, value := range shape { 4312 var col types.DatasetImportJobSummary 4313 destAddr := &col 4314 if err := awsAwsjson11_deserializeDocumentDatasetImportJobSummary(&destAddr, value); err != nil { 4315 return err 4316 } 4317 col = *destAddr 4318 cv = append(cv, col) 4319 4320 } 4321 *v = cv 4322 return nil 4323} 4324 4325func awsAwsjson11_deserializeDocumentDatasetImportJobSummary(v **types.DatasetImportJobSummary, value interface{}) error { 4326 if v == nil { 4327 return fmt.Errorf("unexpected nil of type %T", v) 4328 } 4329 if value == nil { 4330 return nil 4331 } 4332 4333 shape, ok := value.(map[string]interface{}) 4334 if !ok { 4335 return fmt.Errorf("unexpected JSON type %v", value) 4336 } 4337 4338 var sv *types.DatasetImportJobSummary 4339 if *v == nil { 4340 sv = &types.DatasetImportJobSummary{} 4341 } else { 4342 sv = *v 4343 } 4344 4345 for key, value := range shape { 4346 switch key { 4347 case "CreationTime": 4348 if value != nil { 4349 jtv, ok := value.(json.Number) 4350 if !ok { 4351 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4352 } 4353 f64, err := jtv.Float64() 4354 if err != nil { 4355 return err 4356 } 4357 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4358 } 4359 4360 case "DatasetImportJobArn": 4361 if value != nil { 4362 jtv, ok := value.(string) 4363 if !ok { 4364 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4365 } 4366 sv.DatasetImportJobArn = ptr.String(jtv) 4367 } 4368 4369 case "DatasetImportJobName": 4370 if value != nil { 4371 jtv, ok := value.(string) 4372 if !ok { 4373 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 4374 } 4375 sv.DatasetImportJobName = ptr.String(jtv) 4376 } 4377 4378 case "DataSource": 4379 if err := awsAwsjson11_deserializeDocumentDataSource(&sv.DataSource, value); err != nil { 4380 return err 4381 } 4382 4383 case "LastModificationTime": 4384 if value != nil { 4385 jtv, ok := value.(json.Number) 4386 if !ok { 4387 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4388 } 4389 f64, err := jtv.Float64() 4390 if err != nil { 4391 return err 4392 } 4393 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4394 } 4395 4396 case "Message": 4397 if value != nil { 4398 jtv, ok := value.(string) 4399 if !ok { 4400 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4401 } 4402 sv.Message = ptr.String(jtv) 4403 } 4404 4405 case "Status": 4406 if value != nil { 4407 jtv, ok := value.(string) 4408 if !ok { 4409 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 4410 } 4411 sv.Status = ptr.String(jtv) 4412 } 4413 4414 default: 4415 _, _ = key, value 4416 4417 } 4418 } 4419 *v = sv 4420 return nil 4421} 4422 4423func awsAwsjson11_deserializeDocumentDatasets(v *[]types.DatasetSummary, value interface{}) error { 4424 if v == nil { 4425 return fmt.Errorf("unexpected nil of type %T", v) 4426 } 4427 if value == nil { 4428 return nil 4429 } 4430 4431 shape, ok := value.([]interface{}) 4432 if !ok { 4433 return fmt.Errorf("unexpected JSON type %v", value) 4434 } 4435 4436 var cv []types.DatasetSummary 4437 if *v == nil { 4438 cv = []types.DatasetSummary{} 4439 } else { 4440 cv = *v 4441 } 4442 4443 for _, value := range shape { 4444 var col types.DatasetSummary 4445 destAddr := &col 4446 if err := awsAwsjson11_deserializeDocumentDatasetSummary(&destAddr, value); err != nil { 4447 return err 4448 } 4449 col = *destAddr 4450 cv = append(cv, col) 4451 4452 } 4453 *v = cv 4454 return nil 4455} 4456 4457func awsAwsjson11_deserializeDocumentDatasetSummary(v **types.DatasetSummary, value interface{}) error { 4458 if v == nil { 4459 return fmt.Errorf("unexpected nil of type %T", v) 4460 } 4461 if value == nil { 4462 return nil 4463 } 4464 4465 shape, ok := value.(map[string]interface{}) 4466 if !ok { 4467 return fmt.Errorf("unexpected JSON type %v", value) 4468 } 4469 4470 var sv *types.DatasetSummary 4471 if *v == nil { 4472 sv = &types.DatasetSummary{} 4473 } else { 4474 sv = *v 4475 } 4476 4477 for key, value := range shape { 4478 switch key { 4479 case "CreationTime": 4480 if value != nil { 4481 jtv, ok := value.(json.Number) 4482 if !ok { 4483 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4484 } 4485 f64, err := jtv.Float64() 4486 if err != nil { 4487 return err 4488 } 4489 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4490 } 4491 4492 case "DatasetArn": 4493 if value != nil { 4494 jtv, ok := value.(string) 4495 if !ok { 4496 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4497 } 4498 sv.DatasetArn = ptr.String(jtv) 4499 } 4500 4501 case "DatasetName": 4502 if value != nil { 4503 jtv, ok := value.(string) 4504 if !ok { 4505 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 4506 } 4507 sv.DatasetName = ptr.String(jtv) 4508 } 4509 4510 case "DatasetType": 4511 if value != nil { 4512 jtv, ok := value.(string) 4513 if !ok { 4514 return fmt.Errorf("expected DatasetType to be of type string, got %T instead", value) 4515 } 4516 sv.DatasetType = types.DatasetType(jtv) 4517 } 4518 4519 case "Domain": 4520 if value != nil { 4521 jtv, ok := value.(string) 4522 if !ok { 4523 return fmt.Errorf("expected Domain to be of type string, got %T instead", value) 4524 } 4525 sv.Domain = types.Domain(jtv) 4526 } 4527 4528 case "LastModificationTime": 4529 if value != nil { 4530 jtv, ok := value.(json.Number) 4531 if !ok { 4532 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4533 } 4534 f64, err := jtv.Float64() 4535 if err != nil { 4536 return err 4537 } 4538 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4539 } 4540 4541 default: 4542 _, _ = key, value 4543 4544 } 4545 } 4546 *v = sv 4547 return nil 4548} 4549 4550func awsAwsjson11_deserializeDocumentDataSource(v **types.DataSource, value interface{}) error { 4551 if v == nil { 4552 return fmt.Errorf("unexpected nil of type %T", v) 4553 } 4554 if value == nil { 4555 return nil 4556 } 4557 4558 shape, ok := value.(map[string]interface{}) 4559 if !ok { 4560 return fmt.Errorf("unexpected JSON type %v", value) 4561 } 4562 4563 var sv *types.DataSource 4564 if *v == nil { 4565 sv = &types.DataSource{} 4566 } else { 4567 sv = *v 4568 } 4569 4570 for key, value := range shape { 4571 switch key { 4572 case "S3Config": 4573 if err := awsAwsjson11_deserializeDocumentS3Config(&sv.S3Config, value); err != nil { 4574 return err 4575 } 4576 4577 default: 4578 _, _ = key, value 4579 4580 } 4581 } 4582 *v = sv 4583 return nil 4584} 4585 4586func awsAwsjson11_deserializeDocumentEncryptionConfig(v **types.EncryptionConfig, value interface{}) error { 4587 if v == nil { 4588 return fmt.Errorf("unexpected nil of type %T", v) 4589 } 4590 if value == nil { 4591 return nil 4592 } 4593 4594 shape, ok := value.(map[string]interface{}) 4595 if !ok { 4596 return fmt.Errorf("unexpected JSON type %v", value) 4597 } 4598 4599 var sv *types.EncryptionConfig 4600 if *v == nil { 4601 sv = &types.EncryptionConfig{} 4602 } else { 4603 sv = *v 4604 } 4605 4606 for key, value := range shape { 4607 switch key { 4608 case "KMSKeyArn": 4609 if value != nil { 4610 jtv, ok := value.(string) 4611 if !ok { 4612 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 4613 } 4614 sv.KMSKeyArn = ptr.String(jtv) 4615 } 4616 4617 case "RoleArn": 4618 if value != nil { 4619 jtv, ok := value.(string) 4620 if !ok { 4621 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4622 } 4623 sv.RoleArn = ptr.String(jtv) 4624 } 4625 4626 default: 4627 _, _ = key, value 4628 4629 } 4630 } 4631 *v = sv 4632 return nil 4633} 4634 4635func awsAwsjson11_deserializeDocumentErrorMetric(v **types.ErrorMetric, value interface{}) error { 4636 if v == nil { 4637 return fmt.Errorf("unexpected nil of type %T", v) 4638 } 4639 if value == nil { 4640 return nil 4641 } 4642 4643 shape, ok := value.(map[string]interface{}) 4644 if !ok { 4645 return fmt.Errorf("unexpected JSON type %v", value) 4646 } 4647 4648 var sv *types.ErrorMetric 4649 if *v == nil { 4650 sv = &types.ErrorMetric{} 4651 } else { 4652 sv = *v 4653 } 4654 4655 for key, value := range shape { 4656 switch key { 4657 case "ForecastType": 4658 if value != nil { 4659 jtv, ok := value.(string) 4660 if !ok { 4661 return fmt.Errorf("expected ForecastType to be of type string, got %T instead", value) 4662 } 4663 sv.ForecastType = ptr.String(jtv) 4664 } 4665 4666 case "RMSE": 4667 if value != nil { 4668 jtv, ok := value.(json.Number) 4669 if !ok { 4670 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 4671 } 4672 f64, err := jtv.Float64() 4673 if err != nil { 4674 return err 4675 } 4676 sv.RMSE = ptr.Float64(f64) 4677 } 4678 4679 case "WAPE": 4680 if value != nil { 4681 jtv, ok := value.(json.Number) 4682 if !ok { 4683 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 4684 } 4685 f64, err := jtv.Float64() 4686 if err != nil { 4687 return err 4688 } 4689 sv.WAPE = ptr.Float64(f64) 4690 } 4691 4692 default: 4693 _, _ = key, value 4694 4695 } 4696 } 4697 *v = sv 4698 return nil 4699} 4700 4701func awsAwsjson11_deserializeDocumentErrorMetrics(v *[]types.ErrorMetric, value interface{}) error { 4702 if v == nil { 4703 return fmt.Errorf("unexpected nil of type %T", v) 4704 } 4705 if value == nil { 4706 return nil 4707 } 4708 4709 shape, ok := value.([]interface{}) 4710 if !ok { 4711 return fmt.Errorf("unexpected JSON type %v", value) 4712 } 4713 4714 var cv []types.ErrorMetric 4715 if *v == nil { 4716 cv = []types.ErrorMetric{} 4717 } else { 4718 cv = *v 4719 } 4720 4721 for _, value := range shape { 4722 var col types.ErrorMetric 4723 destAddr := &col 4724 if err := awsAwsjson11_deserializeDocumentErrorMetric(&destAddr, value); err != nil { 4725 return err 4726 } 4727 col = *destAddr 4728 cv = append(cv, col) 4729 4730 } 4731 *v = cv 4732 return nil 4733} 4734 4735func awsAwsjson11_deserializeDocumentEvaluationParameters(v **types.EvaluationParameters, value interface{}) error { 4736 if v == nil { 4737 return fmt.Errorf("unexpected nil of type %T", v) 4738 } 4739 if value == nil { 4740 return nil 4741 } 4742 4743 shape, ok := value.(map[string]interface{}) 4744 if !ok { 4745 return fmt.Errorf("unexpected JSON type %v", value) 4746 } 4747 4748 var sv *types.EvaluationParameters 4749 if *v == nil { 4750 sv = &types.EvaluationParameters{} 4751 } else { 4752 sv = *v 4753 } 4754 4755 for key, value := range shape { 4756 switch key { 4757 case "BackTestWindowOffset": 4758 if value != nil { 4759 jtv, ok := value.(json.Number) 4760 if !ok { 4761 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4762 } 4763 i64, err := jtv.Int64() 4764 if err != nil { 4765 return err 4766 } 4767 sv.BackTestWindowOffset = ptr.Int32(int32(i64)) 4768 } 4769 4770 case "NumberOfBacktestWindows": 4771 if value != nil { 4772 jtv, ok := value.(json.Number) 4773 if !ok { 4774 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4775 } 4776 i64, err := jtv.Int64() 4777 if err != nil { 4778 return err 4779 } 4780 sv.NumberOfBacktestWindows = ptr.Int32(int32(i64)) 4781 } 4782 4783 default: 4784 _, _ = key, value 4785 4786 } 4787 } 4788 *v = sv 4789 return nil 4790} 4791 4792func awsAwsjson11_deserializeDocumentEvaluationResult(v **types.EvaluationResult, value interface{}) error { 4793 if v == nil { 4794 return fmt.Errorf("unexpected nil of type %T", v) 4795 } 4796 if value == nil { 4797 return nil 4798 } 4799 4800 shape, ok := value.(map[string]interface{}) 4801 if !ok { 4802 return fmt.Errorf("unexpected JSON type %v", value) 4803 } 4804 4805 var sv *types.EvaluationResult 4806 if *v == nil { 4807 sv = &types.EvaluationResult{} 4808 } else { 4809 sv = *v 4810 } 4811 4812 for key, value := range shape { 4813 switch key { 4814 case "AlgorithmArn": 4815 if value != nil { 4816 jtv, ok := value.(string) 4817 if !ok { 4818 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4819 } 4820 sv.AlgorithmArn = ptr.String(jtv) 4821 } 4822 4823 case "TestWindows": 4824 if err := awsAwsjson11_deserializeDocumentTestWindows(&sv.TestWindows, value); err != nil { 4825 return err 4826 } 4827 4828 default: 4829 _, _ = key, value 4830 4831 } 4832 } 4833 *v = sv 4834 return nil 4835} 4836 4837func awsAwsjson11_deserializeDocumentFeaturization(v **types.Featurization, value interface{}) error { 4838 if v == nil { 4839 return fmt.Errorf("unexpected nil of type %T", v) 4840 } 4841 if value == nil { 4842 return nil 4843 } 4844 4845 shape, ok := value.(map[string]interface{}) 4846 if !ok { 4847 return fmt.Errorf("unexpected JSON type %v", value) 4848 } 4849 4850 var sv *types.Featurization 4851 if *v == nil { 4852 sv = &types.Featurization{} 4853 } else { 4854 sv = *v 4855 } 4856 4857 for key, value := range shape { 4858 switch key { 4859 case "AttributeName": 4860 if value != nil { 4861 jtv, ok := value.(string) 4862 if !ok { 4863 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 4864 } 4865 sv.AttributeName = ptr.String(jtv) 4866 } 4867 4868 case "FeaturizationPipeline": 4869 if err := awsAwsjson11_deserializeDocumentFeaturizationPipeline(&sv.FeaturizationPipeline, value); err != nil { 4870 return err 4871 } 4872 4873 default: 4874 _, _ = key, value 4875 4876 } 4877 } 4878 *v = sv 4879 return nil 4880} 4881 4882func awsAwsjson11_deserializeDocumentFeaturizationConfig(v **types.FeaturizationConfig, value interface{}) error { 4883 if v == nil { 4884 return fmt.Errorf("unexpected nil of type %T", v) 4885 } 4886 if value == nil { 4887 return nil 4888 } 4889 4890 shape, ok := value.(map[string]interface{}) 4891 if !ok { 4892 return fmt.Errorf("unexpected JSON type %v", value) 4893 } 4894 4895 var sv *types.FeaturizationConfig 4896 if *v == nil { 4897 sv = &types.FeaturizationConfig{} 4898 } else { 4899 sv = *v 4900 } 4901 4902 for key, value := range shape { 4903 switch key { 4904 case "Featurizations": 4905 if err := awsAwsjson11_deserializeDocumentFeaturizations(&sv.Featurizations, value); err != nil { 4906 return err 4907 } 4908 4909 case "ForecastDimensions": 4910 if err := awsAwsjson11_deserializeDocumentForecastDimensions(&sv.ForecastDimensions, value); err != nil { 4911 return err 4912 } 4913 4914 case "ForecastFrequency": 4915 if value != nil { 4916 jtv, ok := value.(string) 4917 if !ok { 4918 return fmt.Errorf("expected Frequency to be of type string, got %T instead", value) 4919 } 4920 sv.ForecastFrequency = ptr.String(jtv) 4921 } 4922 4923 default: 4924 _, _ = key, value 4925 4926 } 4927 } 4928 *v = sv 4929 return nil 4930} 4931 4932func awsAwsjson11_deserializeDocumentFeaturizationMethod(v **types.FeaturizationMethod, value interface{}) error { 4933 if v == nil { 4934 return fmt.Errorf("unexpected nil of type %T", v) 4935 } 4936 if value == nil { 4937 return nil 4938 } 4939 4940 shape, ok := value.(map[string]interface{}) 4941 if !ok { 4942 return fmt.Errorf("unexpected JSON type %v", value) 4943 } 4944 4945 var sv *types.FeaturizationMethod 4946 if *v == nil { 4947 sv = &types.FeaturizationMethod{} 4948 } else { 4949 sv = *v 4950 } 4951 4952 for key, value := range shape { 4953 switch key { 4954 case "FeaturizationMethodName": 4955 if value != nil { 4956 jtv, ok := value.(string) 4957 if !ok { 4958 return fmt.Errorf("expected FeaturizationMethodName to be of type string, got %T instead", value) 4959 } 4960 sv.FeaturizationMethodName = types.FeaturizationMethodName(jtv) 4961 } 4962 4963 case "FeaturizationMethodParameters": 4964 if err := awsAwsjson11_deserializeDocumentFeaturizationMethodParameters(&sv.FeaturizationMethodParameters, value); err != nil { 4965 return err 4966 } 4967 4968 default: 4969 _, _ = key, value 4970 4971 } 4972 } 4973 *v = sv 4974 return nil 4975} 4976 4977func awsAwsjson11_deserializeDocumentFeaturizationMethodParameters(v *map[string]string, value interface{}) error { 4978 if v == nil { 4979 return fmt.Errorf("unexpected nil of type %T", v) 4980 } 4981 if value == nil { 4982 return nil 4983 } 4984 4985 shape, ok := value.(map[string]interface{}) 4986 if !ok { 4987 return fmt.Errorf("unexpected JSON type %v", value) 4988 } 4989 4990 var mv map[string]string 4991 if *v == nil { 4992 mv = map[string]string{} 4993 } else { 4994 mv = *v 4995 } 4996 4997 for key, value := range shape { 4998 var parsedVal string 4999 if value != nil { 5000 jtv, ok := value.(string) 5001 if !ok { 5002 return fmt.Errorf("expected ParameterValue to be of type string, got %T instead", value) 5003 } 5004 parsedVal = jtv 5005 } 5006 mv[key] = parsedVal 5007 5008 } 5009 *v = mv 5010 return nil 5011} 5012 5013func awsAwsjson11_deserializeDocumentFeaturizationPipeline(v *[]types.FeaturizationMethod, value interface{}) error { 5014 if v == nil { 5015 return fmt.Errorf("unexpected nil of type %T", v) 5016 } 5017 if value == nil { 5018 return nil 5019 } 5020 5021 shape, ok := value.([]interface{}) 5022 if !ok { 5023 return fmt.Errorf("unexpected JSON type %v", value) 5024 } 5025 5026 var cv []types.FeaturizationMethod 5027 if *v == nil { 5028 cv = []types.FeaturizationMethod{} 5029 } else { 5030 cv = *v 5031 } 5032 5033 for _, value := range shape { 5034 var col types.FeaturizationMethod 5035 destAddr := &col 5036 if err := awsAwsjson11_deserializeDocumentFeaturizationMethod(&destAddr, value); err != nil { 5037 return err 5038 } 5039 col = *destAddr 5040 cv = append(cv, col) 5041 5042 } 5043 *v = cv 5044 return nil 5045} 5046 5047func awsAwsjson11_deserializeDocumentFeaturizations(v *[]types.Featurization, value interface{}) error { 5048 if v == nil { 5049 return fmt.Errorf("unexpected nil of type %T", v) 5050 } 5051 if value == nil { 5052 return nil 5053 } 5054 5055 shape, ok := value.([]interface{}) 5056 if !ok { 5057 return fmt.Errorf("unexpected JSON type %v", value) 5058 } 5059 5060 var cv []types.Featurization 5061 if *v == nil { 5062 cv = []types.Featurization{} 5063 } else { 5064 cv = *v 5065 } 5066 5067 for _, value := range shape { 5068 var col types.Featurization 5069 destAddr := &col 5070 if err := awsAwsjson11_deserializeDocumentFeaturization(&destAddr, value); err != nil { 5071 return err 5072 } 5073 col = *destAddr 5074 cv = append(cv, col) 5075 5076 } 5077 *v = cv 5078 return nil 5079} 5080 5081func awsAwsjson11_deserializeDocumentFieldStatistics(v *map[string]types.Statistics, value interface{}) error { 5082 if v == nil { 5083 return fmt.Errorf("unexpected nil of type %T", v) 5084 } 5085 if value == nil { 5086 return nil 5087 } 5088 5089 shape, ok := value.(map[string]interface{}) 5090 if !ok { 5091 return fmt.Errorf("unexpected JSON type %v", value) 5092 } 5093 5094 var mv map[string]types.Statistics 5095 if *v == nil { 5096 mv = map[string]types.Statistics{} 5097 } else { 5098 mv = *v 5099 } 5100 5101 for key, value := range shape { 5102 var parsedVal types.Statistics 5103 mapVar := parsedVal 5104 destAddr := &mapVar 5105 if err := awsAwsjson11_deserializeDocumentStatistics(&destAddr, value); err != nil { 5106 return err 5107 } 5108 parsedVal = *destAddr 5109 mv[key] = parsedVal 5110 5111 } 5112 *v = mv 5113 return nil 5114} 5115 5116func awsAwsjson11_deserializeDocumentForecastDimensions(v *[]string, value interface{}) error { 5117 if v == nil { 5118 return fmt.Errorf("unexpected nil of type %T", v) 5119 } 5120 if value == nil { 5121 return nil 5122 } 5123 5124 shape, ok := value.([]interface{}) 5125 if !ok { 5126 return fmt.Errorf("unexpected JSON type %v", value) 5127 } 5128 5129 var cv []string 5130 if *v == nil { 5131 cv = []string{} 5132 } else { 5133 cv = *v 5134 } 5135 5136 for _, value := range shape { 5137 var col string 5138 if value != nil { 5139 jtv, ok := value.(string) 5140 if !ok { 5141 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 5142 } 5143 col = jtv 5144 } 5145 cv = append(cv, col) 5146 5147 } 5148 *v = cv 5149 return nil 5150} 5151 5152func awsAwsjson11_deserializeDocumentForecastExportJobs(v *[]types.ForecastExportJobSummary, value interface{}) error { 5153 if v == nil { 5154 return fmt.Errorf("unexpected nil of type %T", v) 5155 } 5156 if value == nil { 5157 return nil 5158 } 5159 5160 shape, ok := value.([]interface{}) 5161 if !ok { 5162 return fmt.Errorf("unexpected JSON type %v", value) 5163 } 5164 5165 var cv []types.ForecastExportJobSummary 5166 if *v == nil { 5167 cv = []types.ForecastExportJobSummary{} 5168 } else { 5169 cv = *v 5170 } 5171 5172 for _, value := range shape { 5173 var col types.ForecastExportJobSummary 5174 destAddr := &col 5175 if err := awsAwsjson11_deserializeDocumentForecastExportJobSummary(&destAddr, value); err != nil { 5176 return err 5177 } 5178 col = *destAddr 5179 cv = append(cv, col) 5180 5181 } 5182 *v = cv 5183 return nil 5184} 5185 5186func awsAwsjson11_deserializeDocumentForecastExportJobSummary(v **types.ForecastExportJobSummary, value interface{}) error { 5187 if v == nil { 5188 return fmt.Errorf("unexpected nil of type %T", v) 5189 } 5190 if value == nil { 5191 return nil 5192 } 5193 5194 shape, ok := value.(map[string]interface{}) 5195 if !ok { 5196 return fmt.Errorf("unexpected JSON type %v", value) 5197 } 5198 5199 var sv *types.ForecastExportJobSummary 5200 if *v == nil { 5201 sv = &types.ForecastExportJobSummary{} 5202 } else { 5203 sv = *v 5204 } 5205 5206 for key, value := range shape { 5207 switch key { 5208 case "CreationTime": 5209 if value != nil { 5210 jtv, ok := value.(json.Number) 5211 if !ok { 5212 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5213 } 5214 f64, err := jtv.Float64() 5215 if err != nil { 5216 return err 5217 } 5218 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5219 } 5220 5221 case "Destination": 5222 if err := awsAwsjson11_deserializeDocumentDataDestination(&sv.Destination, value); err != nil { 5223 return err 5224 } 5225 5226 case "ForecastExportJobArn": 5227 if value != nil { 5228 jtv, ok := value.(string) 5229 if !ok { 5230 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5231 } 5232 sv.ForecastExportJobArn = ptr.String(jtv) 5233 } 5234 5235 case "ForecastExportJobName": 5236 if value != nil { 5237 jtv, ok := value.(string) 5238 if !ok { 5239 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 5240 } 5241 sv.ForecastExportJobName = ptr.String(jtv) 5242 } 5243 5244 case "LastModificationTime": 5245 if value != nil { 5246 jtv, ok := value.(json.Number) 5247 if !ok { 5248 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5249 } 5250 f64, err := jtv.Float64() 5251 if err != nil { 5252 return err 5253 } 5254 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5255 } 5256 5257 case "Message": 5258 if value != nil { 5259 jtv, ok := value.(string) 5260 if !ok { 5261 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5262 } 5263 sv.Message = ptr.String(jtv) 5264 } 5265 5266 case "Status": 5267 if value != nil { 5268 jtv, ok := value.(string) 5269 if !ok { 5270 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 5271 } 5272 sv.Status = ptr.String(jtv) 5273 } 5274 5275 default: 5276 _, _ = key, value 5277 5278 } 5279 } 5280 *v = sv 5281 return nil 5282} 5283 5284func awsAwsjson11_deserializeDocumentForecasts(v *[]types.ForecastSummary, value interface{}) error { 5285 if v == nil { 5286 return fmt.Errorf("unexpected nil of type %T", v) 5287 } 5288 if value == nil { 5289 return nil 5290 } 5291 5292 shape, ok := value.([]interface{}) 5293 if !ok { 5294 return fmt.Errorf("unexpected JSON type %v", value) 5295 } 5296 5297 var cv []types.ForecastSummary 5298 if *v == nil { 5299 cv = []types.ForecastSummary{} 5300 } else { 5301 cv = *v 5302 } 5303 5304 for _, value := range shape { 5305 var col types.ForecastSummary 5306 destAddr := &col 5307 if err := awsAwsjson11_deserializeDocumentForecastSummary(&destAddr, value); err != nil { 5308 return err 5309 } 5310 col = *destAddr 5311 cv = append(cv, col) 5312 5313 } 5314 *v = cv 5315 return nil 5316} 5317 5318func awsAwsjson11_deserializeDocumentForecastSummary(v **types.ForecastSummary, value interface{}) error { 5319 if v == nil { 5320 return fmt.Errorf("unexpected nil of type %T", v) 5321 } 5322 if value == nil { 5323 return nil 5324 } 5325 5326 shape, ok := value.(map[string]interface{}) 5327 if !ok { 5328 return fmt.Errorf("unexpected JSON type %v", value) 5329 } 5330 5331 var sv *types.ForecastSummary 5332 if *v == nil { 5333 sv = &types.ForecastSummary{} 5334 } else { 5335 sv = *v 5336 } 5337 5338 for key, value := range shape { 5339 switch key { 5340 case "CreationTime": 5341 if value != nil { 5342 jtv, ok := value.(json.Number) 5343 if !ok { 5344 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5345 } 5346 f64, err := jtv.Float64() 5347 if err != nil { 5348 return err 5349 } 5350 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5351 } 5352 5353 case "DatasetGroupArn": 5354 if value != nil { 5355 jtv, ok := value.(string) 5356 if !ok { 5357 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5358 } 5359 sv.DatasetGroupArn = ptr.String(jtv) 5360 } 5361 5362 case "ForecastArn": 5363 if value != nil { 5364 jtv, ok := value.(string) 5365 if !ok { 5366 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5367 } 5368 sv.ForecastArn = ptr.String(jtv) 5369 } 5370 5371 case "ForecastName": 5372 if value != nil { 5373 jtv, ok := value.(string) 5374 if !ok { 5375 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 5376 } 5377 sv.ForecastName = ptr.String(jtv) 5378 } 5379 5380 case "LastModificationTime": 5381 if value != nil { 5382 jtv, ok := value.(json.Number) 5383 if !ok { 5384 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5385 } 5386 f64, err := jtv.Float64() 5387 if err != nil { 5388 return err 5389 } 5390 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5391 } 5392 5393 case "Message": 5394 if value != nil { 5395 jtv, ok := value.(string) 5396 if !ok { 5397 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5398 } 5399 sv.Message = ptr.String(jtv) 5400 } 5401 5402 case "PredictorArn": 5403 if value != nil { 5404 jtv, ok := value.(string) 5405 if !ok { 5406 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5407 } 5408 sv.PredictorArn = ptr.String(jtv) 5409 } 5410 5411 case "Status": 5412 if value != nil { 5413 jtv, ok := value.(string) 5414 if !ok { 5415 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 5416 } 5417 sv.Status = ptr.String(jtv) 5418 } 5419 5420 default: 5421 _, _ = key, value 5422 5423 } 5424 } 5425 *v = sv 5426 return nil 5427} 5428 5429func awsAwsjson11_deserializeDocumentForecastTypes(v *[]string, value interface{}) error { 5430 if v == nil { 5431 return fmt.Errorf("unexpected nil of type %T", v) 5432 } 5433 if value == nil { 5434 return nil 5435 } 5436 5437 shape, ok := value.([]interface{}) 5438 if !ok { 5439 return fmt.Errorf("unexpected JSON type %v", value) 5440 } 5441 5442 var cv []string 5443 if *v == nil { 5444 cv = []string{} 5445 } else { 5446 cv = *v 5447 } 5448 5449 for _, value := range shape { 5450 var col string 5451 if value != nil { 5452 jtv, ok := value.(string) 5453 if !ok { 5454 return fmt.Errorf("expected ForecastType to be of type string, got %T instead", value) 5455 } 5456 col = jtv 5457 } 5458 cv = append(cv, col) 5459 5460 } 5461 *v = cv 5462 return nil 5463} 5464 5465func awsAwsjson11_deserializeDocumentHyperParameterTuningJobConfig(v **types.HyperParameterTuningJobConfig, value interface{}) error { 5466 if v == nil { 5467 return fmt.Errorf("unexpected nil of type %T", v) 5468 } 5469 if value == nil { 5470 return nil 5471 } 5472 5473 shape, ok := value.(map[string]interface{}) 5474 if !ok { 5475 return fmt.Errorf("unexpected JSON type %v", value) 5476 } 5477 5478 var sv *types.HyperParameterTuningJobConfig 5479 if *v == nil { 5480 sv = &types.HyperParameterTuningJobConfig{} 5481 } else { 5482 sv = *v 5483 } 5484 5485 for key, value := range shape { 5486 switch key { 5487 case "ParameterRanges": 5488 if err := awsAwsjson11_deserializeDocumentParameterRanges(&sv.ParameterRanges, value); err != nil { 5489 return err 5490 } 5491 5492 default: 5493 _, _ = key, value 5494 5495 } 5496 } 5497 *v = sv 5498 return nil 5499} 5500 5501func awsAwsjson11_deserializeDocumentInputDataConfig(v **types.InputDataConfig, value interface{}) error { 5502 if v == nil { 5503 return fmt.Errorf("unexpected nil of type %T", v) 5504 } 5505 if value == nil { 5506 return nil 5507 } 5508 5509 shape, ok := value.(map[string]interface{}) 5510 if !ok { 5511 return fmt.Errorf("unexpected JSON type %v", value) 5512 } 5513 5514 var sv *types.InputDataConfig 5515 if *v == nil { 5516 sv = &types.InputDataConfig{} 5517 } else { 5518 sv = *v 5519 } 5520 5521 for key, value := range shape { 5522 switch key { 5523 case "DatasetGroupArn": 5524 if value != nil { 5525 jtv, ok := value.(string) 5526 if !ok { 5527 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5528 } 5529 sv.DatasetGroupArn = ptr.String(jtv) 5530 } 5531 5532 case "SupplementaryFeatures": 5533 if err := awsAwsjson11_deserializeDocumentSupplementaryFeatures(&sv.SupplementaryFeatures, value); err != nil { 5534 return err 5535 } 5536 5537 default: 5538 _, _ = key, value 5539 5540 } 5541 } 5542 *v = sv 5543 return nil 5544} 5545 5546func awsAwsjson11_deserializeDocumentIntegerParameterRange(v **types.IntegerParameterRange, value interface{}) error { 5547 if v == nil { 5548 return fmt.Errorf("unexpected nil of type %T", v) 5549 } 5550 if value == nil { 5551 return nil 5552 } 5553 5554 shape, ok := value.(map[string]interface{}) 5555 if !ok { 5556 return fmt.Errorf("unexpected JSON type %v", value) 5557 } 5558 5559 var sv *types.IntegerParameterRange 5560 if *v == nil { 5561 sv = &types.IntegerParameterRange{} 5562 } else { 5563 sv = *v 5564 } 5565 5566 for key, value := range shape { 5567 switch key { 5568 case "MaxValue": 5569 if value != nil { 5570 jtv, ok := value.(json.Number) 5571 if !ok { 5572 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5573 } 5574 i64, err := jtv.Int64() 5575 if err != nil { 5576 return err 5577 } 5578 sv.MaxValue = ptr.Int32(int32(i64)) 5579 } 5580 5581 case "MinValue": 5582 if value != nil { 5583 jtv, ok := value.(json.Number) 5584 if !ok { 5585 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5586 } 5587 i64, err := jtv.Int64() 5588 if err != nil { 5589 return err 5590 } 5591 sv.MinValue = ptr.Int32(int32(i64)) 5592 } 5593 5594 case "Name": 5595 if value != nil { 5596 jtv, ok := value.(string) 5597 if !ok { 5598 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 5599 } 5600 sv.Name = ptr.String(jtv) 5601 } 5602 5603 case "ScalingType": 5604 if value != nil { 5605 jtv, ok := value.(string) 5606 if !ok { 5607 return fmt.Errorf("expected ScalingType to be of type string, got %T instead", value) 5608 } 5609 sv.ScalingType = types.ScalingType(jtv) 5610 } 5611 5612 default: 5613 _, _ = key, value 5614 5615 } 5616 } 5617 *v = sv 5618 return nil 5619} 5620 5621func awsAwsjson11_deserializeDocumentIntegerParameterRanges(v *[]types.IntegerParameterRange, value interface{}) error { 5622 if v == nil { 5623 return fmt.Errorf("unexpected nil of type %T", v) 5624 } 5625 if value == nil { 5626 return nil 5627 } 5628 5629 shape, ok := value.([]interface{}) 5630 if !ok { 5631 return fmt.Errorf("unexpected JSON type %v", value) 5632 } 5633 5634 var cv []types.IntegerParameterRange 5635 if *v == nil { 5636 cv = []types.IntegerParameterRange{} 5637 } else { 5638 cv = *v 5639 } 5640 5641 for _, value := range shape { 5642 var col types.IntegerParameterRange 5643 destAddr := &col 5644 if err := awsAwsjson11_deserializeDocumentIntegerParameterRange(&destAddr, value); err != nil { 5645 return err 5646 } 5647 col = *destAddr 5648 cv = append(cv, col) 5649 5650 } 5651 *v = cv 5652 return nil 5653} 5654 5655func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error { 5656 if v == nil { 5657 return fmt.Errorf("unexpected nil of type %T", v) 5658 } 5659 if value == nil { 5660 return nil 5661 } 5662 5663 shape, ok := value.(map[string]interface{}) 5664 if !ok { 5665 return fmt.Errorf("unexpected JSON type %v", value) 5666 } 5667 5668 var sv *types.InvalidInputException 5669 if *v == nil { 5670 sv = &types.InvalidInputException{} 5671 } else { 5672 sv = *v 5673 } 5674 5675 for key, value := range shape { 5676 switch key { 5677 case "Message": 5678 if value != nil { 5679 jtv, ok := value.(string) 5680 if !ok { 5681 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5682 } 5683 sv.Message = ptr.String(jtv) 5684 } 5685 5686 default: 5687 _, _ = key, value 5688 5689 } 5690 } 5691 *v = sv 5692 return nil 5693} 5694 5695func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 5696 if v == nil { 5697 return fmt.Errorf("unexpected nil of type %T", v) 5698 } 5699 if value == nil { 5700 return nil 5701 } 5702 5703 shape, ok := value.(map[string]interface{}) 5704 if !ok { 5705 return fmt.Errorf("unexpected JSON type %v", value) 5706 } 5707 5708 var sv *types.InvalidNextTokenException 5709 if *v == nil { 5710 sv = &types.InvalidNextTokenException{} 5711 } else { 5712 sv = *v 5713 } 5714 5715 for key, value := range shape { 5716 switch key { 5717 case "Message": 5718 if value != nil { 5719 jtv, ok := value.(string) 5720 if !ok { 5721 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5722 } 5723 sv.Message = ptr.String(jtv) 5724 } 5725 5726 default: 5727 _, _ = key, value 5728 5729 } 5730 } 5731 *v = sv 5732 return nil 5733} 5734 5735func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 5736 if v == nil { 5737 return fmt.Errorf("unexpected nil of type %T", v) 5738 } 5739 if value == nil { 5740 return nil 5741 } 5742 5743 shape, ok := value.(map[string]interface{}) 5744 if !ok { 5745 return fmt.Errorf("unexpected JSON type %v", value) 5746 } 5747 5748 var sv *types.LimitExceededException 5749 if *v == nil { 5750 sv = &types.LimitExceededException{} 5751 } else { 5752 sv = *v 5753 } 5754 5755 for key, value := range shape { 5756 switch key { 5757 case "Message": 5758 if value != nil { 5759 jtv, ok := value.(string) 5760 if !ok { 5761 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5762 } 5763 sv.Message = ptr.String(jtv) 5764 } 5765 5766 default: 5767 _, _ = key, value 5768 5769 } 5770 } 5771 *v = sv 5772 return nil 5773} 5774 5775func awsAwsjson11_deserializeDocumentMetrics(v **types.Metrics, value interface{}) error { 5776 if v == nil { 5777 return fmt.Errorf("unexpected nil of type %T", v) 5778 } 5779 if value == nil { 5780 return nil 5781 } 5782 5783 shape, ok := value.(map[string]interface{}) 5784 if !ok { 5785 return fmt.Errorf("unexpected JSON type %v", value) 5786 } 5787 5788 var sv *types.Metrics 5789 if *v == nil { 5790 sv = &types.Metrics{} 5791 } else { 5792 sv = *v 5793 } 5794 5795 for key, value := range shape { 5796 switch key { 5797 case "ErrorMetrics": 5798 if err := awsAwsjson11_deserializeDocumentErrorMetrics(&sv.ErrorMetrics, value); err != nil { 5799 return err 5800 } 5801 5802 case "RMSE": 5803 if value != nil { 5804 jtv, ok := value.(json.Number) 5805 if !ok { 5806 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 5807 } 5808 f64, err := jtv.Float64() 5809 if err != nil { 5810 return err 5811 } 5812 sv.RMSE = ptr.Float64(f64) 5813 } 5814 5815 case "WeightedQuantileLosses": 5816 if err := awsAwsjson11_deserializeDocumentWeightedQuantileLosses(&sv.WeightedQuantileLosses, value); err != nil { 5817 return err 5818 } 5819 5820 default: 5821 _, _ = key, value 5822 5823 } 5824 } 5825 *v = sv 5826 return nil 5827} 5828 5829func awsAwsjson11_deserializeDocumentParameterRanges(v **types.ParameterRanges, value interface{}) error { 5830 if v == nil { 5831 return fmt.Errorf("unexpected nil of type %T", v) 5832 } 5833 if value == nil { 5834 return nil 5835 } 5836 5837 shape, ok := value.(map[string]interface{}) 5838 if !ok { 5839 return fmt.Errorf("unexpected JSON type %v", value) 5840 } 5841 5842 var sv *types.ParameterRanges 5843 if *v == nil { 5844 sv = &types.ParameterRanges{} 5845 } else { 5846 sv = *v 5847 } 5848 5849 for key, value := range shape { 5850 switch key { 5851 case "CategoricalParameterRanges": 5852 if err := awsAwsjson11_deserializeDocumentCategoricalParameterRanges(&sv.CategoricalParameterRanges, value); err != nil { 5853 return err 5854 } 5855 5856 case "ContinuousParameterRanges": 5857 if err := awsAwsjson11_deserializeDocumentContinuousParameterRanges(&sv.ContinuousParameterRanges, value); err != nil { 5858 return err 5859 } 5860 5861 case "IntegerParameterRanges": 5862 if err := awsAwsjson11_deserializeDocumentIntegerParameterRanges(&sv.IntegerParameterRanges, value); err != nil { 5863 return err 5864 } 5865 5866 default: 5867 _, _ = key, value 5868 5869 } 5870 } 5871 *v = sv 5872 return nil 5873} 5874 5875func awsAwsjson11_deserializeDocumentPredictorBacktestExportJobs(v *[]types.PredictorBacktestExportJobSummary, value interface{}) error { 5876 if v == nil { 5877 return fmt.Errorf("unexpected nil of type %T", v) 5878 } 5879 if value == nil { 5880 return nil 5881 } 5882 5883 shape, ok := value.([]interface{}) 5884 if !ok { 5885 return fmt.Errorf("unexpected JSON type %v", value) 5886 } 5887 5888 var cv []types.PredictorBacktestExportJobSummary 5889 if *v == nil { 5890 cv = []types.PredictorBacktestExportJobSummary{} 5891 } else { 5892 cv = *v 5893 } 5894 5895 for _, value := range shape { 5896 var col types.PredictorBacktestExportJobSummary 5897 destAddr := &col 5898 if err := awsAwsjson11_deserializeDocumentPredictorBacktestExportJobSummary(&destAddr, value); err != nil { 5899 return err 5900 } 5901 col = *destAddr 5902 cv = append(cv, col) 5903 5904 } 5905 *v = cv 5906 return nil 5907} 5908 5909func awsAwsjson11_deserializeDocumentPredictorBacktestExportJobSummary(v **types.PredictorBacktestExportJobSummary, value interface{}) error { 5910 if v == nil { 5911 return fmt.Errorf("unexpected nil of type %T", v) 5912 } 5913 if value == nil { 5914 return nil 5915 } 5916 5917 shape, ok := value.(map[string]interface{}) 5918 if !ok { 5919 return fmt.Errorf("unexpected JSON type %v", value) 5920 } 5921 5922 var sv *types.PredictorBacktestExportJobSummary 5923 if *v == nil { 5924 sv = &types.PredictorBacktestExportJobSummary{} 5925 } else { 5926 sv = *v 5927 } 5928 5929 for key, value := range shape { 5930 switch key { 5931 case "CreationTime": 5932 if value != nil { 5933 jtv, ok := value.(json.Number) 5934 if !ok { 5935 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5936 } 5937 f64, err := jtv.Float64() 5938 if err != nil { 5939 return err 5940 } 5941 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5942 } 5943 5944 case "Destination": 5945 if err := awsAwsjson11_deserializeDocumentDataDestination(&sv.Destination, value); err != nil { 5946 return err 5947 } 5948 5949 case "LastModificationTime": 5950 if value != nil { 5951 jtv, ok := value.(json.Number) 5952 if !ok { 5953 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5954 } 5955 f64, err := jtv.Float64() 5956 if err != nil { 5957 return err 5958 } 5959 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5960 } 5961 5962 case "Message": 5963 if value != nil { 5964 jtv, ok := value.(string) 5965 if !ok { 5966 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5967 } 5968 sv.Message = ptr.String(jtv) 5969 } 5970 5971 case "PredictorBacktestExportJobArn": 5972 if value != nil { 5973 jtv, ok := value.(string) 5974 if !ok { 5975 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5976 } 5977 sv.PredictorBacktestExportJobArn = ptr.String(jtv) 5978 } 5979 5980 case "PredictorBacktestExportJobName": 5981 if value != nil { 5982 jtv, ok := value.(string) 5983 if !ok { 5984 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 5985 } 5986 sv.PredictorBacktestExportJobName = ptr.String(jtv) 5987 } 5988 5989 case "Status": 5990 if value != nil { 5991 jtv, ok := value.(string) 5992 if !ok { 5993 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 5994 } 5995 sv.Status = ptr.String(jtv) 5996 } 5997 5998 default: 5999 _, _ = key, value 6000 6001 } 6002 } 6003 *v = sv 6004 return nil 6005} 6006 6007func awsAwsjson11_deserializeDocumentPredictorEvaluationResults(v *[]types.EvaluationResult, value interface{}) error { 6008 if v == nil { 6009 return fmt.Errorf("unexpected nil of type %T", v) 6010 } 6011 if value == nil { 6012 return nil 6013 } 6014 6015 shape, ok := value.([]interface{}) 6016 if !ok { 6017 return fmt.Errorf("unexpected JSON type %v", value) 6018 } 6019 6020 var cv []types.EvaluationResult 6021 if *v == nil { 6022 cv = []types.EvaluationResult{} 6023 } else { 6024 cv = *v 6025 } 6026 6027 for _, value := range shape { 6028 var col types.EvaluationResult 6029 destAddr := &col 6030 if err := awsAwsjson11_deserializeDocumentEvaluationResult(&destAddr, value); err != nil { 6031 return err 6032 } 6033 col = *destAddr 6034 cv = append(cv, col) 6035 6036 } 6037 *v = cv 6038 return nil 6039} 6040 6041func awsAwsjson11_deserializeDocumentPredictorExecution(v **types.PredictorExecution, value interface{}) error { 6042 if v == nil { 6043 return fmt.Errorf("unexpected nil of type %T", v) 6044 } 6045 if value == nil { 6046 return nil 6047 } 6048 6049 shape, ok := value.(map[string]interface{}) 6050 if !ok { 6051 return fmt.Errorf("unexpected JSON type %v", value) 6052 } 6053 6054 var sv *types.PredictorExecution 6055 if *v == nil { 6056 sv = &types.PredictorExecution{} 6057 } else { 6058 sv = *v 6059 } 6060 6061 for key, value := range shape { 6062 switch key { 6063 case "AlgorithmArn": 6064 if value != nil { 6065 jtv, ok := value.(string) 6066 if !ok { 6067 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6068 } 6069 sv.AlgorithmArn = ptr.String(jtv) 6070 } 6071 6072 case "TestWindows": 6073 if err := awsAwsjson11_deserializeDocumentTestWindowDetails(&sv.TestWindows, value); err != nil { 6074 return err 6075 } 6076 6077 default: 6078 _, _ = key, value 6079 6080 } 6081 } 6082 *v = sv 6083 return nil 6084} 6085 6086func awsAwsjson11_deserializeDocumentPredictorExecutionDetails(v **types.PredictorExecutionDetails, value interface{}) error { 6087 if v == nil { 6088 return fmt.Errorf("unexpected nil of type %T", v) 6089 } 6090 if value == nil { 6091 return nil 6092 } 6093 6094 shape, ok := value.(map[string]interface{}) 6095 if !ok { 6096 return fmt.Errorf("unexpected JSON type %v", value) 6097 } 6098 6099 var sv *types.PredictorExecutionDetails 6100 if *v == nil { 6101 sv = &types.PredictorExecutionDetails{} 6102 } else { 6103 sv = *v 6104 } 6105 6106 for key, value := range shape { 6107 switch key { 6108 case "PredictorExecutions": 6109 if err := awsAwsjson11_deserializeDocumentPredictorExecutions(&sv.PredictorExecutions, value); err != nil { 6110 return err 6111 } 6112 6113 default: 6114 _, _ = key, value 6115 6116 } 6117 } 6118 *v = sv 6119 return nil 6120} 6121 6122func awsAwsjson11_deserializeDocumentPredictorExecutions(v *[]types.PredictorExecution, value interface{}) error { 6123 if v == nil { 6124 return fmt.Errorf("unexpected nil of type %T", v) 6125 } 6126 if value == nil { 6127 return nil 6128 } 6129 6130 shape, ok := value.([]interface{}) 6131 if !ok { 6132 return fmt.Errorf("unexpected JSON type %v", value) 6133 } 6134 6135 var cv []types.PredictorExecution 6136 if *v == nil { 6137 cv = []types.PredictorExecution{} 6138 } else { 6139 cv = *v 6140 } 6141 6142 for _, value := range shape { 6143 var col types.PredictorExecution 6144 destAddr := &col 6145 if err := awsAwsjson11_deserializeDocumentPredictorExecution(&destAddr, value); err != nil { 6146 return err 6147 } 6148 col = *destAddr 6149 cv = append(cv, col) 6150 6151 } 6152 *v = cv 6153 return nil 6154} 6155 6156func awsAwsjson11_deserializeDocumentPredictors(v *[]types.PredictorSummary, value interface{}) error { 6157 if v == nil { 6158 return fmt.Errorf("unexpected nil of type %T", v) 6159 } 6160 if value == nil { 6161 return nil 6162 } 6163 6164 shape, ok := value.([]interface{}) 6165 if !ok { 6166 return fmt.Errorf("unexpected JSON type %v", value) 6167 } 6168 6169 var cv []types.PredictorSummary 6170 if *v == nil { 6171 cv = []types.PredictorSummary{} 6172 } else { 6173 cv = *v 6174 } 6175 6176 for _, value := range shape { 6177 var col types.PredictorSummary 6178 destAddr := &col 6179 if err := awsAwsjson11_deserializeDocumentPredictorSummary(&destAddr, value); err != nil { 6180 return err 6181 } 6182 col = *destAddr 6183 cv = append(cv, col) 6184 6185 } 6186 *v = cv 6187 return nil 6188} 6189 6190func awsAwsjson11_deserializeDocumentPredictorSummary(v **types.PredictorSummary, value interface{}) error { 6191 if v == nil { 6192 return fmt.Errorf("unexpected nil of type %T", v) 6193 } 6194 if value == nil { 6195 return nil 6196 } 6197 6198 shape, ok := value.(map[string]interface{}) 6199 if !ok { 6200 return fmt.Errorf("unexpected JSON type %v", value) 6201 } 6202 6203 var sv *types.PredictorSummary 6204 if *v == nil { 6205 sv = &types.PredictorSummary{} 6206 } else { 6207 sv = *v 6208 } 6209 6210 for key, value := range shape { 6211 switch key { 6212 case "CreationTime": 6213 if value != nil { 6214 jtv, ok := value.(json.Number) 6215 if !ok { 6216 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6217 } 6218 f64, err := jtv.Float64() 6219 if err != nil { 6220 return err 6221 } 6222 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6223 } 6224 6225 case "DatasetGroupArn": 6226 if value != nil { 6227 jtv, ok := value.(string) 6228 if !ok { 6229 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6230 } 6231 sv.DatasetGroupArn = ptr.String(jtv) 6232 } 6233 6234 case "LastModificationTime": 6235 if value != nil { 6236 jtv, ok := value.(json.Number) 6237 if !ok { 6238 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6239 } 6240 f64, err := jtv.Float64() 6241 if err != nil { 6242 return err 6243 } 6244 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6245 } 6246 6247 case "Message": 6248 if value != nil { 6249 jtv, ok := value.(string) 6250 if !ok { 6251 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6252 } 6253 sv.Message = ptr.String(jtv) 6254 } 6255 6256 case "PredictorArn": 6257 if value != nil { 6258 jtv, ok := value.(string) 6259 if !ok { 6260 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6261 } 6262 sv.PredictorArn = ptr.String(jtv) 6263 } 6264 6265 case "PredictorName": 6266 if value != nil { 6267 jtv, ok := value.(string) 6268 if !ok { 6269 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 6270 } 6271 sv.PredictorName = ptr.String(jtv) 6272 } 6273 6274 case "Status": 6275 if value != nil { 6276 jtv, ok := value.(string) 6277 if !ok { 6278 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 6279 } 6280 sv.Status = ptr.String(jtv) 6281 } 6282 6283 default: 6284 _, _ = key, value 6285 6286 } 6287 } 6288 *v = sv 6289 return nil 6290} 6291 6292func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, value interface{}) error { 6293 if v == nil { 6294 return fmt.Errorf("unexpected nil of type %T", v) 6295 } 6296 if value == nil { 6297 return nil 6298 } 6299 6300 shape, ok := value.(map[string]interface{}) 6301 if !ok { 6302 return fmt.Errorf("unexpected JSON type %v", value) 6303 } 6304 6305 var sv *types.ResourceAlreadyExistsException 6306 if *v == nil { 6307 sv = &types.ResourceAlreadyExistsException{} 6308 } else { 6309 sv = *v 6310 } 6311 6312 for key, value := range shape { 6313 switch key { 6314 case "Message": 6315 if value != nil { 6316 jtv, ok := value.(string) 6317 if !ok { 6318 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6319 } 6320 sv.Message = ptr.String(jtv) 6321 } 6322 6323 default: 6324 _, _ = key, value 6325 6326 } 6327 } 6328 *v = sv 6329 return nil 6330} 6331 6332func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 6333 if v == nil { 6334 return fmt.Errorf("unexpected nil of type %T", v) 6335 } 6336 if value == nil { 6337 return nil 6338 } 6339 6340 shape, ok := value.(map[string]interface{}) 6341 if !ok { 6342 return fmt.Errorf("unexpected JSON type %v", value) 6343 } 6344 6345 var sv *types.ResourceInUseException 6346 if *v == nil { 6347 sv = &types.ResourceInUseException{} 6348 } else { 6349 sv = *v 6350 } 6351 6352 for key, value := range shape { 6353 switch key { 6354 case "Message": 6355 if value != nil { 6356 jtv, ok := value.(string) 6357 if !ok { 6358 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6359 } 6360 sv.Message = ptr.String(jtv) 6361 } 6362 6363 default: 6364 _, _ = key, value 6365 6366 } 6367 } 6368 *v = sv 6369 return nil 6370} 6371 6372func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 6373 if v == nil { 6374 return fmt.Errorf("unexpected nil of type %T", v) 6375 } 6376 if value == nil { 6377 return nil 6378 } 6379 6380 shape, ok := value.(map[string]interface{}) 6381 if !ok { 6382 return fmt.Errorf("unexpected JSON type %v", value) 6383 } 6384 6385 var sv *types.ResourceNotFoundException 6386 if *v == nil { 6387 sv = &types.ResourceNotFoundException{} 6388 } else { 6389 sv = *v 6390 } 6391 6392 for key, value := range shape { 6393 switch key { 6394 case "Message": 6395 if value != nil { 6396 jtv, ok := value.(string) 6397 if !ok { 6398 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6399 } 6400 sv.Message = ptr.String(jtv) 6401 } 6402 6403 default: 6404 _, _ = key, value 6405 6406 } 6407 } 6408 *v = sv 6409 return nil 6410} 6411 6412func awsAwsjson11_deserializeDocumentS3Config(v **types.S3Config, value interface{}) error { 6413 if v == nil { 6414 return fmt.Errorf("unexpected nil of type %T", v) 6415 } 6416 if value == nil { 6417 return nil 6418 } 6419 6420 shape, ok := value.(map[string]interface{}) 6421 if !ok { 6422 return fmt.Errorf("unexpected JSON type %v", value) 6423 } 6424 6425 var sv *types.S3Config 6426 if *v == nil { 6427 sv = &types.S3Config{} 6428 } else { 6429 sv = *v 6430 } 6431 6432 for key, value := range shape { 6433 switch key { 6434 case "KMSKeyArn": 6435 if value != nil { 6436 jtv, ok := value.(string) 6437 if !ok { 6438 return fmt.Errorf("expected KMSKeyArn to be of type string, got %T instead", value) 6439 } 6440 sv.KMSKeyArn = ptr.String(jtv) 6441 } 6442 6443 case "Path": 6444 if value != nil { 6445 jtv, ok := value.(string) 6446 if !ok { 6447 return fmt.Errorf("expected S3Path to be of type string, got %T instead", value) 6448 } 6449 sv.Path = ptr.String(jtv) 6450 } 6451 6452 case "RoleArn": 6453 if value != nil { 6454 jtv, ok := value.(string) 6455 if !ok { 6456 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6457 } 6458 sv.RoleArn = ptr.String(jtv) 6459 } 6460 6461 default: 6462 _, _ = key, value 6463 6464 } 6465 } 6466 *v = sv 6467 return nil 6468} 6469 6470func awsAwsjson11_deserializeDocumentSchema(v **types.Schema, value interface{}) error { 6471 if v == nil { 6472 return fmt.Errorf("unexpected nil of type %T", v) 6473 } 6474 if value == nil { 6475 return nil 6476 } 6477 6478 shape, ok := value.(map[string]interface{}) 6479 if !ok { 6480 return fmt.Errorf("unexpected JSON type %v", value) 6481 } 6482 6483 var sv *types.Schema 6484 if *v == nil { 6485 sv = &types.Schema{} 6486 } else { 6487 sv = *v 6488 } 6489 6490 for key, value := range shape { 6491 switch key { 6492 case "Attributes": 6493 if err := awsAwsjson11_deserializeDocumentSchemaAttributes(&sv.Attributes, value); err != nil { 6494 return err 6495 } 6496 6497 default: 6498 _, _ = key, value 6499 6500 } 6501 } 6502 *v = sv 6503 return nil 6504} 6505 6506func awsAwsjson11_deserializeDocumentSchemaAttribute(v **types.SchemaAttribute, value interface{}) error { 6507 if v == nil { 6508 return fmt.Errorf("unexpected nil of type %T", v) 6509 } 6510 if value == nil { 6511 return nil 6512 } 6513 6514 shape, ok := value.(map[string]interface{}) 6515 if !ok { 6516 return fmt.Errorf("unexpected JSON type %v", value) 6517 } 6518 6519 var sv *types.SchemaAttribute 6520 if *v == nil { 6521 sv = &types.SchemaAttribute{} 6522 } else { 6523 sv = *v 6524 } 6525 6526 for key, value := range shape { 6527 switch key { 6528 case "AttributeName": 6529 if value != nil { 6530 jtv, ok := value.(string) 6531 if !ok { 6532 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 6533 } 6534 sv.AttributeName = ptr.String(jtv) 6535 } 6536 6537 case "AttributeType": 6538 if value != nil { 6539 jtv, ok := value.(string) 6540 if !ok { 6541 return fmt.Errorf("expected AttributeType to be of type string, got %T instead", value) 6542 } 6543 sv.AttributeType = types.AttributeType(jtv) 6544 } 6545 6546 default: 6547 _, _ = key, value 6548 6549 } 6550 } 6551 *v = sv 6552 return nil 6553} 6554 6555func awsAwsjson11_deserializeDocumentSchemaAttributes(v *[]types.SchemaAttribute, value interface{}) error { 6556 if v == nil { 6557 return fmt.Errorf("unexpected nil of type %T", v) 6558 } 6559 if value == nil { 6560 return nil 6561 } 6562 6563 shape, ok := value.([]interface{}) 6564 if !ok { 6565 return fmt.Errorf("unexpected JSON type %v", value) 6566 } 6567 6568 var cv []types.SchemaAttribute 6569 if *v == nil { 6570 cv = []types.SchemaAttribute{} 6571 } else { 6572 cv = *v 6573 } 6574 6575 for _, value := range shape { 6576 var col types.SchemaAttribute 6577 destAddr := &col 6578 if err := awsAwsjson11_deserializeDocumentSchemaAttribute(&destAddr, value); err != nil { 6579 return err 6580 } 6581 col = *destAddr 6582 cv = append(cv, col) 6583 6584 } 6585 *v = cv 6586 return nil 6587} 6588 6589func awsAwsjson11_deserializeDocumentStatistics(v **types.Statistics, value interface{}) error { 6590 if v == nil { 6591 return fmt.Errorf("unexpected nil of type %T", v) 6592 } 6593 if value == nil { 6594 return nil 6595 } 6596 6597 shape, ok := value.(map[string]interface{}) 6598 if !ok { 6599 return fmt.Errorf("unexpected JSON type %v", value) 6600 } 6601 6602 var sv *types.Statistics 6603 if *v == nil { 6604 sv = &types.Statistics{} 6605 } else { 6606 sv = *v 6607 } 6608 6609 for key, value := range shape { 6610 switch key { 6611 case "Avg": 6612 if value != nil { 6613 jtv, ok := value.(json.Number) 6614 if !ok { 6615 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 6616 } 6617 f64, err := jtv.Float64() 6618 if err != nil { 6619 return err 6620 } 6621 sv.Avg = ptr.Float64(f64) 6622 } 6623 6624 case "Count": 6625 if value != nil { 6626 jtv, ok := value.(json.Number) 6627 if !ok { 6628 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6629 } 6630 i64, err := jtv.Int64() 6631 if err != nil { 6632 return err 6633 } 6634 sv.Count = ptr.Int32(int32(i64)) 6635 } 6636 6637 case "CountDistinct": 6638 if value != nil { 6639 jtv, ok := value.(json.Number) 6640 if !ok { 6641 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6642 } 6643 i64, err := jtv.Int64() 6644 if err != nil { 6645 return err 6646 } 6647 sv.CountDistinct = ptr.Int32(int32(i64)) 6648 } 6649 6650 case "CountNan": 6651 if value != nil { 6652 jtv, ok := value.(json.Number) 6653 if !ok { 6654 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6655 } 6656 i64, err := jtv.Int64() 6657 if err != nil { 6658 return err 6659 } 6660 sv.CountNan = ptr.Int32(int32(i64)) 6661 } 6662 6663 case "CountNull": 6664 if value != nil { 6665 jtv, ok := value.(json.Number) 6666 if !ok { 6667 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6668 } 6669 i64, err := jtv.Int64() 6670 if err != nil { 6671 return err 6672 } 6673 sv.CountNull = ptr.Int32(int32(i64)) 6674 } 6675 6676 case "Max": 6677 if value != nil { 6678 jtv, ok := value.(string) 6679 if !ok { 6680 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6681 } 6682 sv.Max = ptr.String(jtv) 6683 } 6684 6685 case "Min": 6686 if value != nil { 6687 jtv, ok := value.(string) 6688 if !ok { 6689 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6690 } 6691 sv.Min = ptr.String(jtv) 6692 } 6693 6694 case "Stddev": 6695 if value != nil { 6696 jtv, ok := value.(json.Number) 6697 if !ok { 6698 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 6699 } 6700 f64, err := jtv.Float64() 6701 if err != nil { 6702 return err 6703 } 6704 sv.Stddev = ptr.Float64(f64) 6705 } 6706 6707 default: 6708 _, _ = key, value 6709 6710 } 6711 } 6712 *v = sv 6713 return nil 6714} 6715 6716func awsAwsjson11_deserializeDocumentSupplementaryFeature(v **types.SupplementaryFeature, value interface{}) error { 6717 if v == nil { 6718 return fmt.Errorf("unexpected nil of type %T", v) 6719 } 6720 if value == nil { 6721 return nil 6722 } 6723 6724 shape, ok := value.(map[string]interface{}) 6725 if !ok { 6726 return fmt.Errorf("unexpected JSON type %v", value) 6727 } 6728 6729 var sv *types.SupplementaryFeature 6730 if *v == nil { 6731 sv = &types.SupplementaryFeature{} 6732 } else { 6733 sv = *v 6734 } 6735 6736 for key, value := range shape { 6737 switch key { 6738 case "Name": 6739 if value != nil { 6740 jtv, ok := value.(string) 6741 if !ok { 6742 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 6743 } 6744 sv.Name = ptr.String(jtv) 6745 } 6746 6747 case "Value": 6748 if value != nil { 6749 jtv, ok := value.(string) 6750 if !ok { 6751 return fmt.Errorf("expected Value to be of type string, got %T instead", value) 6752 } 6753 sv.Value = ptr.String(jtv) 6754 } 6755 6756 default: 6757 _, _ = key, value 6758 6759 } 6760 } 6761 *v = sv 6762 return nil 6763} 6764 6765func awsAwsjson11_deserializeDocumentSupplementaryFeatures(v *[]types.SupplementaryFeature, value interface{}) error { 6766 if v == nil { 6767 return fmt.Errorf("unexpected nil of type %T", v) 6768 } 6769 if value == nil { 6770 return nil 6771 } 6772 6773 shape, ok := value.([]interface{}) 6774 if !ok { 6775 return fmt.Errorf("unexpected JSON type %v", value) 6776 } 6777 6778 var cv []types.SupplementaryFeature 6779 if *v == nil { 6780 cv = []types.SupplementaryFeature{} 6781 } else { 6782 cv = *v 6783 } 6784 6785 for _, value := range shape { 6786 var col types.SupplementaryFeature 6787 destAddr := &col 6788 if err := awsAwsjson11_deserializeDocumentSupplementaryFeature(&destAddr, value); err != nil { 6789 return err 6790 } 6791 col = *destAddr 6792 cv = append(cv, col) 6793 6794 } 6795 *v = cv 6796 return nil 6797} 6798 6799func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 6800 if v == nil { 6801 return fmt.Errorf("unexpected nil of type %T", v) 6802 } 6803 if value == nil { 6804 return nil 6805 } 6806 6807 shape, ok := value.(map[string]interface{}) 6808 if !ok { 6809 return fmt.Errorf("unexpected JSON type %v", value) 6810 } 6811 6812 var sv *types.Tag 6813 if *v == nil { 6814 sv = &types.Tag{} 6815 } else { 6816 sv = *v 6817 } 6818 6819 for key, value := range shape { 6820 switch key { 6821 case "Key": 6822 if value != nil { 6823 jtv, ok := value.(string) 6824 if !ok { 6825 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 6826 } 6827 sv.Key = ptr.String(jtv) 6828 } 6829 6830 case "Value": 6831 if value != nil { 6832 jtv, ok := value.(string) 6833 if !ok { 6834 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 6835 } 6836 sv.Value = ptr.String(jtv) 6837 } 6838 6839 default: 6840 _, _ = key, value 6841 6842 } 6843 } 6844 *v = sv 6845 return nil 6846} 6847 6848func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 6849 if v == nil { 6850 return fmt.Errorf("unexpected nil of type %T", v) 6851 } 6852 if value == nil { 6853 return nil 6854 } 6855 6856 shape, ok := value.([]interface{}) 6857 if !ok { 6858 return fmt.Errorf("unexpected JSON type %v", value) 6859 } 6860 6861 var cv []types.Tag 6862 if *v == nil { 6863 cv = []types.Tag{} 6864 } else { 6865 cv = *v 6866 } 6867 6868 for _, value := range shape { 6869 var col types.Tag 6870 destAddr := &col 6871 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 6872 return err 6873 } 6874 col = *destAddr 6875 cv = append(cv, col) 6876 6877 } 6878 *v = cv 6879 return nil 6880} 6881 6882func awsAwsjson11_deserializeDocumentTestWindowDetails(v *[]types.TestWindowSummary, value interface{}) error { 6883 if v == nil { 6884 return fmt.Errorf("unexpected nil of type %T", v) 6885 } 6886 if value == nil { 6887 return nil 6888 } 6889 6890 shape, ok := value.([]interface{}) 6891 if !ok { 6892 return fmt.Errorf("unexpected JSON type %v", value) 6893 } 6894 6895 var cv []types.TestWindowSummary 6896 if *v == nil { 6897 cv = []types.TestWindowSummary{} 6898 } else { 6899 cv = *v 6900 } 6901 6902 for _, value := range shape { 6903 var col types.TestWindowSummary 6904 destAddr := &col 6905 if err := awsAwsjson11_deserializeDocumentTestWindowSummary(&destAddr, value); err != nil { 6906 return err 6907 } 6908 col = *destAddr 6909 cv = append(cv, col) 6910 6911 } 6912 *v = cv 6913 return nil 6914} 6915 6916func awsAwsjson11_deserializeDocumentTestWindows(v *[]types.WindowSummary, value interface{}) error { 6917 if v == nil { 6918 return fmt.Errorf("unexpected nil of type %T", v) 6919 } 6920 if value == nil { 6921 return nil 6922 } 6923 6924 shape, ok := value.([]interface{}) 6925 if !ok { 6926 return fmt.Errorf("unexpected JSON type %v", value) 6927 } 6928 6929 var cv []types.WindowSummary 6930 if *v == nil { 6931 cv = []types.WindowSummary{} 6932 } else { 6933 cv = *v 6934 } 6935 6936 for _, value := range shape { 6937 var col types.WindowSummary 6938 destAddr := &col 6939 if err := awsAwsjson11_deserializeDocumentWindowSummary(&destAddr, value); err != nil { 6940 return err 6941 } 6942 col = *destAddr 6943 cv = append(cv, col) 6944 6945 } 6946 *v = cv 6947 return nil 6948} 6949 6950func awsAwsjson11_deserializeDocumentTestWindowSummary(v **types.TestWindowSummary, value interface{}) error { 6951 if v == nil { 6952 return fmt.Errorf("unexpected nil of type %T", v) 6953 } 6954 if value == nil { 6955 return nil 6956 } 6957 6958 shape, ok := value.(map[string]interface{}) 6959 if !ok { 6960 return fmt.Errorf("unexpected JSON type %v", value) 6961 } 6962 6963 var sv *types.TestWindowSummary 6964 if *v == nil { 6965 sv = &types.TestWindowSummary{} 6966 } else { 6967 sv = *v 6968 } 6969 6970 for key, value := range shape { 6971 switch key { 6972 case "Message": 6973 if value != nil { 6974 jtv, ok := value.(string) 6975 if !ok { 6976 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6977 } 6978 sv.Message = ptr.String(jtv) 6979 } 6980 6981 case "Status": 6982 if value != nil { 6983 jtv, ok := value.(string) 6984 if !ok { 6985 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 6986 } 6987 sv.Status = ptr.String(jtv) 6988 } 6989 6990 case "TestWindowEnd": 6991 if value != nil { 6992 jtv, ok := value.(json.Number) 6993 if !ok { 6994 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6995 } 6996 f64, err := jtv.Float64() 6997 if err != nil { 6998 return err 6999 } 7000 sv.TestWindowEnd = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7001 } 7002 7003 case "TestWindowStart": 7004 if value != nil { 7005 jtv, ok := value.(json.Number) 7006 if !ok { 7007 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7008 } 7009 f64, err := jtv.Float64() 7010 if err != nil { 7011 return err 7012 } 7013 sv.TestWindowStart = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7014 } 7015 7016 default: 7017 _, _ = key, value 7018 7019 } 7020 } 7021 *v = sv 7022 return nil 7023} 7024 7025func awsAwsjson11_deserializeDocumentTrainingParameters(v *map[string]string, value interface{}) error { 7026 if v == nil { 7027 return fmt.Errorf("unexpected nil of type %T", v) 7028 } 7029 if value == nil { 7030 return nil 7031 } 7032 7033 shape, ok := value.(map[string]interface{}) 7034 if !ok { 7035 return fmt.Errorf("unexpected JSON type %v", value) 7036 } 7037 7038 var mv map[string]string 7039 if *v == nil { 7040 mv = map[string]string{} 7041 } else { 7042 mv = *v 7043 } 7044 7045 for key, value := range shape { 7046 var parsedVal string 7047 if value != nil { 7048 jtv, ok := value.(string) 7049 if !ok { 7050 return fmt.Errorf("expected ParameterValue to be of type string, got %T instead", value) 7051 } 7052 parsedVal = jtv 7053 } 7054 mv[key] = parsedVal 7055 7056 } 7057 *v = mv 7058 return nil 7059} 7060 7061func awsAwsjson11_deserializeDocumentValues(v *[]string, value interface{}) error { 7062 if v == nil { 7063 return fmt.Errorf("unexpected nil of type %T", v) 7064 } 7065 if value == nil { 7066 return nil 7067 } 7068 7069 shape, ok := value.([]interface{}) 7070 if !ok { 7071 return fmt.Errorf("unexpected JSON type %v", value) 7072 } 7073 7074 var cv []string 7075 if *v == nil { 7076 cv = []string{} 7077 } else { 7078 cv = *v 7079 } 7080 7081 for _, value := range shape { 7082 var col string 7083 if value != nil { 7084 jtv, ok := value.(string) 7085 if !ok { 7086 return fmt.Errorf("expected Value to be of type string, got %T instead", value) 7087 } 7088 col = jtv 7089 } 7090 cv = append(cv, col) 7091 7092 } 7093 *v = cv 7094 return nil 7095} 7096 7097func awsAwsjson11_deserializeDocumentWeightedQuantileLoss(v **types.WeightedQuantileLoss, value interface{}) error { 7098 if v == nil { 7099 return fmt.Errorf("unexpected nil of type %T", v) 7100 } 7101 if value == nil { 7102 return nil 7103 } 7104 7105 shape, ok := value.(map[string]interface{}) 7106 if !ok { 7107 return fmt.Errorf("unexpected JSON type %v", value) 7108 } 7109 7110 var sv *types.WeightedQuantileLoss 7111 if *v == nil { 7112 sv = &types.WeightedQuantileLoss{} 7113 } else { 7114 sv = *v 7115 } 7116 7117 for key, value := range shape { 7118 switch key { 7119 case "LossValue": 7120 if value != nil { 7121 jtv, ok := value.(json.Number) 7122 if !ok { 7123 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 7124 } 7125 f64, err := jtv.Float64() 7126 if err != nil { 7127 return err 7128 } 7129 sv.LossValue = ptr.Float64(f64) 7130 } 7131 7132 case "Quantile": 7133 if value != nil { 7134 jtv, ok := value.(json.Number) 7135 if !ok { 7136 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 7137 } 7138 f64, err := jtv.Float64() 7139 if err != nil { 7140 return err 7141 } 7142 sv.Quantile = ptr.Float64(f64) 7143 } 7144 7145 default: 7146 _, _ = key, value 7147 7148 } 7149 } 7150 *v = sv 7151 return nil 7152} 7153 7154func awsAwsjson11_deserializeDocumentWeightedQuantileLosses(v *[]types.WeightedQuantileLoss, value interface{}) error { 7155 if v == nil { 7156 return fmt.Errorf("unexpected nil of type %T", v) 7157 } 7158 if value == nil { 7159 return nil 7160 } 7161 7162 shape, ok := value.([]interface{}) 7163 if !ok { 7164 return fmt.Errorf("unexpected JSON type %v", value) 7165 } 7166 7167 var cv []types.WeightedQuantileLoss 7168 if *v == nil { 7169 cv = []types.WeightedQuantileLoss{} 7170 } else { 7171 cv = *v 7172 } 7173 7174 for _, value := range shape { 7175 var col types.WeightedQuantileLoss 7176 destAddr := &col 7177 if err := awsAwsjson11_deserializeDocumentWeightedQuantileLoss(&destAddr, value); err != nil { 7178 return err 7179 } 7180 col = *destAddr 7181 cv = append(cv, col) 7182 7183 } 7184 *v = cv 7185 return nil 7186} 7187 7188func awsAwsjson11_deserializeDocumentWindowSummary(v **types.WindowSummary, value interface{}) error { 7189 if v == nil { 7190 return fmt.Errorf("unexpected nil of type %T", v) 7191 } 7192 if value == nil { 7193 return nil 7194 } 7195 7196 shape, ok := value.(map[string]interface{}) 7197 if !ok { 7198 return fmt.Errorf("unexpected JSON type %v", value) 7199 } 7200 7201 var sv *types.WindowSummary 7202 if *v == nil { 7203 sv = &types.WindowSummary{} 7204 } else { 7205 sv = *v 7206 } 7207 7208 for key, value := range shape { 7209 switch key { 7210 case "EvaluationType": 7211 if value != nil { 7212 jtv, ok := value.(string) 7213 if !ok { 7214 return fmt.Errorf("expected EvaluationType to be of type string, got %T instead", value) 7215 } 7216 sv.EvaluationType = types.EvaluationType(jtv) 7217 } 7218 7219 case "ItemCount": 7220 if value != nil { 7221 jtv, ok := value.(json.Number) 7222 if !ok { 7223 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7224 } 7225 i64, err := jtv.Int64() 7226 if err != nil { 7227 return err 7228 } 7229 sv.ItemCount = ptr.Int32(int32(i64)) 7230 } 7231 7232 case "Metrics": 7233 if err := awsAwsjson11_deserializeDocumentMetrics(&sv.Metrics, value); err != nil { 7234 return err 7235 } 7236 7237 case "TestWindowEnd": 7238 if value != nil { 7239 jtv, ok := value.(json.Number) 7240 if !ok { 7241 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7242 } 7243 f64, err := jtv.Float64() 7244 if err != nil { 7245 return err 7246 } 7247 sv.TestWindowEnd = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7248 } 7249 7250 case "TestWindowStart": 7251 if value != nil { 7252 jtv, ok := value.(json.Number) 7253 if !ok { 7254 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7255 } 7256 f64, err := jtv.Float64() 7257 if err != nil { 7258 return err 7259 } 7260 sv.TestWindowStart = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7261 } 7262 7263 default: 7264 _, _ = key, value 7265 7266 } 7267 } 7268 *v = sv 7269 return nil 7270} 7271 7272func awsAwsjson11_deserializeOpDocumentCreateDatasetGroupOutput(v **CreateDatasetGroupOutput, value interface{}) error { 7273 if v == nil { 7274 return fmt.Errorf("unexpected nil of type %T", v) 7275 } 7276 if value == nil { 7277 return nil 7278 } 7279 7280 shape, ok := value.(map[string]interface{}) 7281 if !ok { 7282 return fmt.Errorf("unexpected JSON type %v", value) 7283 } 7284 7285 var sv *CreateDatasetGroupOutput 7286 if *v == nil { 7287 sv = &CreateDatasetGroupOutput{} 7288 } else { 7289 sv = *v 7290 } 7291 7292 for key, value := range shape { 7293 switch key { 7294 case "DatasetGroupArn": 7295 if value != nil { 7296 jtv, ok := value.(string) 7297 if !ok { 7298 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7299 } 7300 sv.DatasetGroupArn = ptr.String(jtv) 7301 } 7302 7303 default: 7304 _, _ = key, value 7305 7306 } 7307 } 7308 *v = sv 7309 return nil 7310} 7311 7312func awsAwsjson11_deserializeOpDocumentCreateDatasetImportJobOutput(v **CreateDatasetImportJobOutput, value interface{}) error { 7313 if v == nil { 7314 return fmt.Errorf("unexpected nil of type %T", v) 7315 } 7316 if value == nil { 7317 return nil 7318 } 7319 7320 shape, ok := value.(map[string]interface{}) 7321 if !ok { 7322 return fmt.Errorf("unexpected JSON type %v", value) 7323 } 7324 7325 var sv *CreateDatasetImportJobOutput 7326 if *v == nil { 7327 sv = &CreateDatasetImportJobOutput{} 7328 } else { 7329 sv = *v 7330 } 7331 7332 for key, value := range shape { 7333 switch key { 7334 case "DatasetImportJobArn": 7335 if value != nil { 7336 jtv, ok := value.(string) 7337 if !ok { 7338 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7339 } 7340 sv.DatasetImportJobArn = ptr.String(jtv) 7341 } 7342 7343 default: 7344 _, _ = key, value 7345 7346 } 7347 } 7348 *v = sv 7349 return nil 7350} 7351 7352func awsAwsjson11_deserializeOpDocumentCreateDatasetOutput(v **CreateDatasetOutput, value interface{}) error { 7353 if v == nil { 7354 return fmt.Errorf("unexpected nil of type %T", v) 7355 } 7356 if value == nil { 7357 return nil 7358 } 7359 7360 shape, ok := value.(map[string]interface{}) 7361 if !ok { 7362 return fmt.Errorf("unexpected JSON type %v", value) 7363 } 7364 7365 var sv *CreateDatasetOutput 7366 if *v == nil { 7367 sv = &CreateDatasetOutput{} 7368 } else { 7369 sv = *v 7370 } 7371 7372 for key, value := range shape { 7373 switch key { 7374 case "DatasetArn": 7375 if value != nil { 7376 jtv, ok := value.(string) 7377 if !ok { 7378 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7379 } 7380 sv.DatasetArn = ptr.String(jtv) 7381 } 7382 7383 default: 7384 _, _ = key, value 7385 7386 } 7387 } 7388 *v = sv 7389 return nil 7390} 7391 7392func awsAwsjson11_deserializeOpDocumentCreateForecastExportJobOutput(v **CreateForecastExportJobOutput, value interface{}) error { 7393 if v == nil { 7394 return fmt.Errorf("unexpected nil of type %T", v) 7395 } 7396 if value == nil { 7397 return nil 7398 } 7399 7400 shape, ok := value.(map[string]interface{}) 7401 if !ok { 7402 return fmt.Errorf("unexpected JSON type %v", value) 7403 } 7404 7405 var sv *CreateForecastExportJobOutput 7406 if *v == nil { 7407 sv = &CreateForecastExportJobOutput{} 7408 } else { 7409 sv = *v 7410 } 7411 7412 for key, value := range shape { 7413 switch key { 7414 case "ForecastExportJobArn": 7415 if value != nil { 7416 jtv, ok := value.(string) 7417 if !ok { 7418 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7419 } 7420 sv.ForecastExportJobArn = ptr.String(jtv) 7421 } 7422 7423 default: 7424 _, _ = key, value 7425 7426 } 7427 } 7428 *v = sv 7429 return nil 7430} 7431 7432func awsAwsjson11_deserializeOpDocumentCreateForecastOutput(v **CreateForecastOutput, value interface{}) error { 7433 if v == nil { 7434 return fmt.Errorf("unexpected nil of type %T", v) 7435 } 7436 if value == nil { 7437 return nil 7438 } 7439 7440 shape, ok := value.(map[string]interface{}) 7441 if !ok { 7442 return fmt.Errorf("unexpected JSON type %v", value) 7443 } 7444 7445 var sv *CreateForecastOutput 7446 if *v == nil { 7447 sv = &CreateForecastOutput{} 7448 } else { 7449 sv = *v 7450 } 7451 7452 for key, value := range shape { 7453 switch key { 7454 case "ForecastArn": 7455 if value != nil { 7456 jtv, ok := value.(string) 7457 if !ok { 7458 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7459 } 7460 sv.ForecastArn = ptr.String(jtv) 7461 } 7462 7463 default: 7464 _, _ = key, value 7465 7466 } 7467 } 7468 *v = sv 7469 return nil 7470} 7471 7472func awsAwsjson11_deserializeOpDocumentCreatePredictorBacktestExportJobOutput(v **CreatePredictorBacktestExportJobOutput, value interface{}) error { 7473 if v == nil { 7474 return fmt.Errorf("unexpected nil of type %T", v) 7475 } 7476 if value == nil { 7477 return nil 7478 } 7479 7480 shape, ok := value.(map[string]interface{}) 7481 if !ok { 7482 return fmt.Errorf("unexpected JSON type %v", value) 7483 } 7484 7485 var sv *CreatePredictorBacktestExportJobOutput 7486 if *v == nil { 7487 sv = &CreatePredictorBacktestExportJobOutput{} 7488 } else { 7489 sv = *v 7490 } 7491 7492 for key, value := range shape { 7493 switch key { 7494 case "PredictorBacktestExportJobArn": 7495 if value != nil { 7496 jtv, ok := value.(string) 7497 if !ok { 7498 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7499 } 7500 sv.PredictorBacktestExportJobArn = ptr.String(jtv) 7501 } 7502 7503 default: 7504 _, _ = key, value 7505 7506 } 7507 } 7508 *v = sv 7509 return nil 7510} 7511 7512func awsAwsjson11_deserializeOpDocumentCreatePredictorOutput(v **CreatePredictorOutput, value interface{}) error { 7513 if v == nil { 7514 return fmt.Errorf("unexpected nil of type %T", v) 7515 } 7516 if value == nil { 7517 return nil 7518 } 7519 7520 shape, ok := value.(map[string]interface{}) 7521 if !ok { 7522 return fmt.Errorf("unexpected JSON type %v", value) 7523 } 7524 7525 var sv *CreatePredictorOutput 7526 if *v == nil { 7527 sv = &CreatePredictorOutput{} 7528 } else { 7529 sv = *v 7530 } 7531 7532 for key, value := range shape { 7533 switch key { 7534 case "PredictorArn": 7535 if value != nil { 7536 jtv, ok := value.(string) 7537 if !ok { 7538 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7539 } 7540 sv.PredictorArn = ptr.String(jtv) 7541 } 7542 7543 default: 7544 _, _ = key, value 7545 7546 } 7547 } 7548 *v = sv 7549 return nil 7550} 7551 7552func awsAwsjson11_deserializeOpDocumentDescribeDatasetGroupOutput(v **DescribeDatasetGroupOutput, value interface{}) error { 7553 if v == nil { 7554 return fmt.Errorf("unexpected nil of type %T", v) 7555 } 7556 if value == nil { 7557 return nil 7558 } 7559 7560 shape, ok := value.(map[string]interface{}) 7561 if !ok { 7562 return fmt.Errorf("unexpected JSON type %v", value) 7563 } 7564 7565 var sv *DescribeDatasetGroupOutput 7566 if *v == nil { 7567 sv = &DescribeDatasetGroupOutput{} 7568 } else { 7569 sv = *v 7570 } 7571 7572 for key, value := range shape { 7573 switch key { 7574 case "CreationTime": 7575 if value != nil { 7576 jtv, ok := value.(json.Number) 7577 if !ok { 7578 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7579 } 7580 f64, err := jtv.Float64() 7581 if err != nil { 7582 return err 7583 } 7584 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7585 } 7586 7587 case "DatasetArns": 7588 if err := awsAwsjson11_deserializeDocumentArnList(&sv.DatasetArns, value); err != nil { 7589 return err 7590 } 7591 7592 case "DatasetGroupArn": 7593 if value != nil { 7594 jtv, ok := value.(string) 7595 if !ok { 7596 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7597 } 7598 sv.DatasetGroupArn = ptr.String(jtv) 7599 } 7600 7601 case "DatasetGroupName": 7602 if value != nil { 7603 jtv, ok := value.(string) 7604 if !ok { 7605 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 7606 } 7607 sv.DatasetGroupName = ptr.String(jtv) 7608 } 7609 7610 case "Domain": 7611 if value != nil { 7612 jtv, ok := value.(string) 7613 if !ok { 7614 return fmt.Errorf("expected Domain to be of type string, got %T instead", value) 7615 } 7616 sv.Domain = types.Domain(jtv) 7617 } 7618 7619 case "LastModificationTime": 7620 if value != nil { 7621 jtv, ok := value.(json.Number) 7622 if !ok { 7623 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7624 } 7625 f64, err := jtv.Float64() 7626 if err != nil { 7627 return err 7628 } 7629 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7630 } 7631 7632 case "Status": 7633 if value != nil { 7634 jtv, ok := value.(string) 7635 if !ok { 7636 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 7637 } 7638 sv.Status = ptr.String(jtv) 7639 } 7640 7641 default: 7642 _, _ = key, value 7643 7644 } 7645 } 7646 *v = sv 7647 return nil 7648} 7649 7650func awsAwsjson11_deserializeOpDocumentDescribeDatasetImportJobOutput(v **DescribeDatasetImportJobOutput, value interface{}) error { 7651 if v == nil { 7652 return fmt.Errorf("unexpected nil of type %T", v) 7653 } 7654 if value == nil { 7655 return nil 7656 } 7657 7658 shape, ok := value.(map[string]interface{}) 7659 if !ok { 7660 return fmt.Errorf("unexpected JSON type %v", value) 7661 } 7662 7663 var sv *DescribeDatasetImportJobOutput 7664 if *v == nil { 7665 sv = &DescribeDatasetImportJobOutput{} 7666 } else { 7667 sv = *v 7668 } 7669 7670 for key, value := range shape { 7671 switch key { 7672 case "CreationTime": 7673 if value != nil { 7674 jtv, ok := value.(json.Number) 7675 if !ok { 7676 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7677 } 7678 f64, err := jtv.Float64() 7679 if err != nil { 7680 return err 7681 } 7682 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7683 } 7684 7685 case "DatasetArn": 7686 if value != nil { 7687 jtv, ok := value.(string) 7688 if !ok { 7689 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7690 } 7691 sv.DatasetArn = ptr.String(jtv) 7692 } 7693 7694 case "DatasetImportJobArn": 7695 if value != nil { 7696 jtv, ok := value.(string) 7697 if !ok { 7698 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7699 } 7700 sv.DatasetImportJobArn = ptr.String(jtv) 7701 } 7702 7703 case "DatasetImportJobName": 7704 if value != nil { 7705 jtv, ok := value.(string) 7706 if !ok { 7707 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 7708 } 7709 sv.DatasetImportJobName = ptr.String(jtv) 7710 } 7711 7712 case "DataSize": 7713 if value != nil { 7714 jtv, ok := value.(json.Number) 7715 if !ok { 7716 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 7717 } 7718 f64, err := jtv.Float64() 7719 if err != nil { 7720 return err 7721 } 7722 sv.DataSize = ptr.Float64(f64) 7723 } 7724 7725 case "DataSource": 7726 if err := awsAwsjson11_deserializeDocumentDataSource(&sv.DataSource, value); err != nil { 7727 return err 7728 } 7729 7730 case "FieldStatistics": 7731 if err := awsAwsjson11_deserializeDocumentFieldStatistics(&sv.FieldStatistics, value); err != nil { 7732 return err 7733 } 7734 7735 case "GeolocationFormat": 7736 if value != nil { 7737 jtv, ok := value.(string) 7738 if !ok { 7739 return fmt.Errorf("expected GeolocationFormat to be of type string, got %T instead", value) 7740 } 7741 sv.GeolocationFormat = ptr.String(jtv) 7742 } 7743 7744 case "LastModificationTime": 7745 if value != nil { 7746 jtv, ok := value.(json.Number) 7747 if !ok { 7748 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7749 } 7750 f64, err := jtv.Float64() 7751 if err != nil { 7752 return err 7753 } 7754 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7755 } 7756 7757 case "Message": 7758 if value != nil { 7759 jtv, ok := value.(string) 7760 if !ok { 7761 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7762 } 7763 sv.Message = ptr.String(jtv) 7764 } 7765 7766 case "Status": 7767 if value != nil { 7768 jtv, ok := value.(string) 7769 if !ok { 7770 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 7771 } 7772 sv.Status = ptr.String(jtv) 7773 } 7774 7775 case "TimestampFormat": 7776 if value != nil { 7777 jtv, ok := value.(string) 7778 if !ok { 7779 return fmt.Errorf("expected TimestampFormat to be of type string, got %T instead", value) 7780 } 7781 sv.TimestampFormat = ptr.String(jtv) 7782 } 7783 7784 case "TimeZone": 7785 if value != nil { 7786 jtv, ok := value.(string) 7787 if !ok { 7788 return fmt.Errorf("expected TimeZone to be of type string, got %T instead", value) 7789 } 7790 sv.TimeZone = ptr.String(jtv) 7791 } 7792 7793 case "UseGeolocationForTimeZone": 7794 if value != nil { 7795 jtv, ok := value.(bool) 7796 if !ok { 7797 return fmt.Errorf("expected UseGeolocationForTimeZone to be of type *bool, got %T instead", value) 7798 } 7799 sv.UseGeolocationForTimeZone = jtv 7800 } 7801 7802 default: 7803 _, _ = key, value 7804 7805 } 7806 } 7807 *v = sv 7808 return nil 7809} 7810 7811func awsAwsjson11_deserializeOpDocumentDescribeDatasetOutput(v **DescribeDatasetOutput, value interface{}) error { 7812 if v == nil { 7813 return fmt.Errorf("unexpected nil of type %T", v) 7814 } 7815 if value == nil { 7816 return nil 7817 } 7818 7819 shape, ok := value.(map[string]interface{}) 7820 if !ok { 7821 return fmt.Errorf("unexpected JSON type %v", value) 7822 } 7823 7824 var sv *DescribeDatasetOutput 7825 if *v == nil { 7826 sv = &DescribeDatasetOutput{} 7827 } else { 7828 sv = *v 7829 } 7830 7831 for key, value := range shape { 7832 switch key { 7833 case "CreationTime": 7834 if value != nil { 7835 jtv, ok := value.(json.Number) 7836 if !ok { 7837 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7838 } 7839 f64, err := jtv.Float64() 7840 if err != nil { 7841 return err 7842 } 7843 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7844 } 7845 7846 case "DataFrequency": 7847 if value != nil { 7848 jtv, ok := value.(string) 7849 if !ok { 7850 return fmt.Errorf("expected Frequency to be of type string, got %T instead", value) 7851 } 7852 sv.DataFrequency = ptr.String(jtv) 7853 } 7854 7855 case "DatasetArn": 7856 if value != nil { 7857 jtv, ok := value.(string) 7858 if !ok { 7859 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7860 } 7861 sv.DatasetArn = ptr.String(jtv) 7862 } 7863 7864 case "DatasetName": 7865 if value != nil { 7866 jtv, ok := value.(string) 7867 if !ok { 7868 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 7869 } 7870 sv.DatasetName = ptr.String(jtv) 7871 } 7872 7873 case "DatasetType": 7874 if value != nil { 7875 jtv, ok := value.(string) 7876 if !ok { 7877 return fmt.Errorf("expected DatasetType to be of type string, got %T instead", value) 7878 } 7879 sv.DatasetType = types.DatasetType(jtv) 7880 } 7881 7882 case "Domain": 7883 if value != nil { 7884 jtv, ok := value.(string) 7885 if !ok { 7886 return fmt.Errorf("expected Domain to be of type string, got %T instead", value) 7887 } 7888 sv.Domain = types.Domain(jtv) 7889 } 7890 7891 case "EncryptionConfig": 7892 if err := awsAwsjson11_deserializeDocumentEncryptionConfig(&sv.EncryptionConfig, value); err != nil { 7893 return err 7894 } 7895 7896 case "LastModificationTime": 7897 if value != nil { 7898 jtv, ok := value.(json.Number) 7899 if !ok { 7900 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7901 } 7902 f64, err := jtv.Float64() 7903 if err != nil { 7904 return err 7905 } 7906 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7907 } 7908 7909 case "Schema": 7910 if err := awsAwsjson11_deserializeDocumentSchema(&sv.Schema, value); err != nil { 7911 return err 7912 } 7913 7914 case "Status": 7915 if value != nil { 7916 jtv, ok := value.(string) 7917 if !ok { 7918 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 7919 } 7920 sv.Status = ptr.String(jtv) 7921 } 7922 7923 default: 7924 _, _ = key, value 7925 7926 } 7927 } 7928 *v = sv 7929 return nil 7930} 7931 7932func awsAwsjson11_deserializeOpDocumentDescribeForecastExportJobOutput(v **DescribeForecastExportJobOutput, value interface{}) error { 7933 if v == nil { 7934 return fmt.Errorf("unexpected nil of type %T", v) 7935 } 7936 if value == nil { 7937 return nil 7938 } 7939 7940 shape, ok := value.(map[string]interface{}) 7941 if !ok { 7942 return fmt.Errorf("unexpected JSON type %v", value) 7943 } 7944 7945 var sv *DescribeForecastExportJobOutput 7946 if *v == nil { 7947 sv = &DescribeForecastExportJobOutput{} 7948 } else { 7949 sv = *v 7950 } 7951 7952 for key, value := range shape { 7953 switch key { 7954 case "CreationTime": 7955 if value != nil { 7956 jtv, ok := value.(json.Number) 7957 if !ok { 7958 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7959 } 7960 f64, err := jtv.Float64() 7961 if err != nil { 7962 return err 7963 } 7964 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7965 } 7966 7967 case "Destination": 7968 if err := awsAwsjson11_deserializeDocumentDataDestination(&sv.Destination, value); err != nil { 7969 return err 7970 } 7971 7972 case "ForecastArn": 7973 if value != nil { 7974 jtv, ok := value.(string) 7975 if !ok { 7976 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7977 } 7978 sv.ForecastArn = ptr.String(jtv) 7979 } 7980 7981 case "ForecastExportJobArn": 7982 if value != nil { 7983 jtv, ok := value.(string) 7984 if !ok { 7985 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7986 } 7987 sv.ForecastExportJobArn = ptr.String(jtv) 7988 } 7989 7990 case "ForecastExportJobName": 7991 if value != nil { 7992 jtv, ok := value.(string) 7993 if !ok { 7994 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 7995 } 7996 sv.ForecastExportJobName = ptr.String(jtv) 7997 } 7998 7999 case "LastModificationTime": 8000 if value != nil { 8001 jtv, ok := value.(json.Number) 8002 if !ok { 8003 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8004 } 8005 f64, err := jtv.Float64() 8006 if err != nil { 8007 return err 8008 } 8009 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8010 } 8011 8012 case "Message": 8013 if value != nil { 8014 jtv, ok := value.(string) 8015 if !ok { 8016 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8017 } 8018 sv.Message = ptr.String(jtv) 8019 } 8020 8021 case "Status": 8022 if value != nil { 8023 jtv, ok := value.(string) 8024 if !ok { 8025 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 8026 } 8027 sv.Status = ptr.String(jtv) 8028 } 8029 8030 default: 8031 _, _ = key, value 8032 8033 } 8034 } 8035 *v = sv 8036 return nil 8037} 8038 8039func awsAwsjson11_deserializeOpDocumentDescribeForecastOutput(v **DescribeForecastOutput, value interface{}) error { 8040 if v == nil { 8041 return fmt.Errorf("unexpected nil of type %T", v) 8042 } 8043 if value == nil { 8044 return nil 8045 } 8046 8047 shape, ok := value.(map[string]interface{}) 8048 if !ok { 8049 return fmt.Errorf("unexpected JSON type %v", value) 8050 } 8051 8052 var sv *DescribeForecastOutput 8053 if *v == nil { 8054 sv = &DescribeForecastOutput{} 8055 } else { 8056 sv = *v 8057 } 8058 8059 for key, value := range shape { 8060 switch key { 8061 case "CreationTime": 8062 if value != nil { 8063 jtv, ok := value.(json.Number) 8064 if !ok { 8065 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8066 } 8067 f64, err := jtv.Float64() 8068 if err != nil { 8069 return err 8070 } 8071 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8072 } 8073 8074 case "DatasetGroupArn": 8075 if value != nil { 8076 jtv, ok := value.(string) 8077 if !ok { 8078 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8079 } 8080 sv.DatasetGroupArn = ptr.String(jtv) 8081 } 8082 8083 case "ForecastArn": 8084 if value != nil { 8085 jtv, ok := value.(string) 8086 if !ok { 8087 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8088 } 8089 sv.ForecastArn = ptr.String(jtv) 8090 } 8091 8092 case "ForecastName": 8093 if value != nil { 8094 jtv, ok := value.(string) 8095 if !ok { 8096 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8097 } 8098 sv.ForecastName = ptr.String(jtv) 8099 } 8100 8101 case "ForecastTypes": 8102 if err := awsAwsjson11_deserializeDocumentForecastTypes(&sv.ForecastTypes, value); err != nil { 8103 return err 8104 } 8105 8106 case "LastModificationTime": 8107 if value != nil { 8108 jtv, ok := value.(json.Number) 8109 if !ok { 8110 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8111 } 8112 f64, err := jtv.Float64() 8113 if err != nil { 8114 return err 8115 } 8116 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8117 } 8118 8119 case "Message": 8120 if value != nil { 8121 jtv, ok := value.(string) 8122 if !ok { 8123 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8124 } 8125 sv.Message = ptr.String(jtv) 8126 } 8127 8128 case "PredictorArn": 8129 if value != nil { 8130 jtv, ok := value.(string) 8131 if !ok { 8132 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8133 } 8134 sv.PredictorArn = ptr.String(jtv) 8135 } 8136 8137 case "Status": 8138 if value != nil { 8139 jtv, ok := value.(string) 8140 if !ok { 8141 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8142 } 8143 sv.Status = ptr.String(jtv) 8144 } 8145 8146 default: 8147 _, _ = key, value 8148 8149 } 8150 } 8151 *v = sv 8152 return nil 8153} 8154 8155func awsAwsjson11_deserializeOpDocumentDescribePredictorBacktestExportJobOutput(v **DescribePredictorBacktestExportJobOutput, value interface{}) error { 8156 if v == nil { 8157 return fmt.Errorf("unexpected nil of type %T", v) 8158 } 8159 if value == nil { 8160 return nil 8161 } 8162 8163 shape, ok := value.(map[string]interface{}) 8164 if !ok { 8165 return fmt.Errorf("unexpected JSON type %v", value) 8166 } 8167 8168 var sv *DescribePredictorBacktestExportJobOutput 8169 if *v == nil { 8170 sv = &DescribePredictorBacktestExportJobOutput{} 8171 } else { 8172 sv = *v 8173 } 8174 8175 for key, value := range shape { 8176 switch key { 8177 case "CreationTime": 8178 if value != nil { 8179 jtv, ok := value.(json.Number) 8180 if !ok { 8181 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8182 } 8183 f64, err := jtv.Float64() 8184 if err != nil { 8185 return err 8186 } 8187 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8188 } 8189 8190 case "Destination": 8191 if err := awsAwsjson11_deserializeDocumentDataDestination(&sv.Destination, value); err != nil { 8192 return err 8193 } 8194 8195 case "LastModificationTime": 8196 if value != nil { 8197 jtv, ok := value.(json.Number) 8198 if !ok { 8199 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8200 } 8201 f64, err := jtv.Float64() 8202 if err != nil { 8203 return err 8204 } 8205 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8206 } 8207 8208 case "Message": 8209 if value != nil { 8210 jtv, ok := value.(string) 8211 if !ok { 8212 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8213 } 8214 sv.Message = ptr.String(jtv) 8215 } 8216 8217 case "PredictorArn": 8218 if value != nil { 8219 jtv, ok := value.(string) 8220 if !ok { 8221 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8222 } 8223 sv.PredictorArn = ptr.String(jtv) 8224 } 8225 8226 case "PredictorBacktestExportJobArn": 8227 if value != nil { 8228 jtv, ok := value.(string) 8229 if !ok { 8230 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8231 } 8232 sv.PredictorBacktestExportJobArn = ptr.String(jtv) 8233 } 8234 8235 case "PredictorBacktestExportJobName": 8236 if value != nil { 8237 jtv, ok := value.(string) 8238 if !ok { 8239 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8240 } 8241 sv.PredictorBacktestExportJobName = ptr.String(jtv) 8242 } 8243 8244 case "Status": 8245 if value != nil { 8246 jtv, ok := value.(string) 8247 if !ok { 8248 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 8249 } 8250 sv.Status = ptr.String(jtv) 8251 } 8252 8253 default: 8254 _, _ = key, value 8255 8256 } 8257 } 8258 *v = sv 8259 return nil 8260} 8261 8262func awsAwsjson11_deserializeOpDocumentDescribePredictorOutput(v **DescribePredictorOutput, value interface{}) error { 8263 if v == nil { 8264 return fmt.Errorf("unexpected nil of type %T", v) 8265 } 8266 if value == nil { 8267 return nil 8268 } 8269 8270 shape, ok := value.(map[string]interface{}) 8271 if !ok { 8272 return fmt.Errorf("unexpected JSON type %v", value) 8273 } 8274 8275 var sv *DescribePredictorOutput 8276 if *v == nil { 8277 sv = &DescribePredictorOutput{} 8278 } else { 8279 sv = *v 8280 } 8281 8282 for key, value := range shape { 8283 switch key { 8284 case "AlgorithmArn": 8285 if value != nil { 8286 jtv, ok := value.(string) 8287 if !ok { 8288 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8289 } 8290 sv.AlgorithmArn = ptr.String(jtv) 8291 } 8292 8293 case "AutoMLAlgorithmArns": 8294 if err := awsAwsjson11_deserializeDocumentArnList(&sv.AutoMLAlgorithmArns, value); err != nil { 8295 return err 8296 } 8297 8298 case "CreationTime": 8299 if value != nil { 8300 jtv, ok := value.(json.Number) 8301 if !ok { 8302 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8303 } 8304 f64, err := jtv.Float64() 8305 if err != nil { 8306 return err 8307 } 8308 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8309 } 8310 8311 case "DatasetImportJobArns": 8312 if err := awsAwsjson11_deserializeDocumentArnList(&sv.DatasetImportJobArns, value); err != nil { 8313 return err 8314 } 8315 8316 case "EncryptionConfig": 8317 if err := awsAwsjson11_deserializeDocumentEncryptionConfig(&sv.EncryptionConfig, value); err != nil { 8318 return err 8319 } 8320 8321 case "EvaluationParameters": 8322 if err := awsAwsjson11_deserializeDocumentEvaluationParameters(&sv.EvaluationParameters, value); err != nil { 8323 return err 8324 } 8325 8326 case "FeaturizationConfig": 8327 if err := awsAwsjson11_deserializeDocumentFeaturizationConfig(&sv.FeaturizationConfig, value); err != nil { 8328 return err 8329 } 8330 8331 case "ForecastHorizon": 8332 if value != nil { 8333 jtv, ok := value.(json.Number) 8334 if !ok { 8335 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8336 } 8337 i64, err := jtv.Int64() 8338 if err != nil { 8339 return err 8340 } 8341 sv.ForecastHorizon = ptr.Int32(int32(i64)) 8342 } 8343 8344 case "ForecastTypes": 8345 if err := awsAwsjson11_deserializeDocumentForecastTypes(&sv.ForecastTypes, value); err != nil { 8346 return err 8347 } 8348 8349 case "HPOConfig": 8350 if err := awsAwsjson11_deserializeDocumentHyperParameterTuningJobConfig(&sv.HPOConfig, value); err != nil { 8351 return err 8352 } 8353 8354 case "InputDataConfig": 8355 if err := awsAwsjson11_deserializeDocumentInputDataConfig(&sv.InputDataConfig, value); err != nil { 8356 return err 8357 } 8358 8359 case "LastModificationTime": 8360 if value != nil { 8361 jtv, ok := value.(json.Number) 8362 if !ok { 8363 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8364 } 8365 f64, err := jtv.Float64() 8366 if err != nil { 8367 return err 8368 } 8369 sv.LastModificationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8370 } 8371 8372 case "Message": 8373 if value != nil { 8374 jtv, ok := value.(string) 8375 if !ok { 8376 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8377 } 8378 sv.Message = ptr.String(jtv) 8379 } 8380 8381 case "PerformAutoML": 8382 if value != nil { 8383 jtv, ok := value.(bool) 8384 if !ok { 8385 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8386 } 8387 sv.PerformAutoML = ptr.Bool(jtv) 8388 } 8389 8390 case "PerformHPO": 8391 if value != nil { 8392 jtv, ok := value.(bool) 8393 if !ok { 8394 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8395 } 8396 sv.PerformHPO = ptr.Bool(jtv) 8397 } 8398 8399 case "PredictorArn": 8400 if value != nil { 8401 jtv, ok := value.(string) 8402 if !ok { 8403 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8404 } 8405 sv.PredictorArn = ptr.String(jtv) 8406 } 8407 8408 case "PredictorExecutionDetails": 8409 if err := awsAwsjson11_deserializeDocumentPredictorExecutionDetails(&sv.PredictorExecutionDetails, value); err != nil { 8410 return err 8411 } 8412 8413 case "PredictorName": 8414 if value != nil { 8415 jtv, ok := value.(string) 8416 if !ok { 8417 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8418 } 8419 sv.PredictorName = ptr.String(jtv) 8420 } 8421 8422 case "Status": 8423 if value != nil { 8424 jtv, ok := value.(string) 8425 if !ok { 8426 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 8427 } 8428 sv.Status = ptr.String(jtv) 8429 } 8430 8431 case "TrainingParameters": 8432 if err := awsAwsjson11_deserializeDocumentTrainingParameters(&sv.TrainingParameters, value); err != nil { 8433 return err 8434 } 8435 8436 default: 8437 _, _ = key, value 8438 8439 } 8440 } 8441 *v = sv 8442 return nil 8443} 8444 8445func awsAwsjson11_deserializeOpDocumentGetAccuracyMetricsOutput(v **GetAccuracyMetricsOutput, value interface{}) error { 8446 if v == nil { 8447 return fmt.Errorf("unexpected nil of type %T", v) 8448 } 8449 if value == nil { 8450 return nil 8451 } 8452 8453 shape, ok := value.(map[string]interface{}) 8454 if !ok { 8455 return fmt.Errorf("unexpected JSON type %v", value) 8456 } 8457 8458 var sv *GetAccuracyMetricsOutput 8459 if *v == nil { 8460 sv = &GetAccuracyMetricsOutput{} 8461 } else { 8462 sv = *v 8463 } 8464 8465 for key, value := range shape { 8466 switch key { 8467 case "PredictorEvaluationResults": 8468 if err := awsAwsjson11_deserializeDocumentPredictorEvaluationResults(&sv.PredictorEvaluationResults, value); err != nil { 8469 return err 8470 } 8471 8472 default: 8473 _, _ = key, value 8474 8475 } 8476 } 8477 *v = sv 8478 return nil 8479} 8480 8481func awsAwsjson11_deserializeOpDocumentListDatasetGroupsOutput(v **ListDatasetGroupsOutput, value interface{}) error { 8482 if v == nil { 8483 return fmt.Errorf("unexpected nil of type %T", v) 8484 } 8485 if value == nil { 8486 return nil 8487 } 8488 8489 shape, ok := value.(map[string]interface{}) 8490 if !ok { 8491 return fmt.Errorf("unexpected JSON type %v", value) 8492 } 8493 8494 var sv *ListDatasetGroupsOutput 8495 if *v == nil { 8496 sv = &ListDatasetGroupsOutput{} 8497 } else { 8498 sv = *v 8499 } 8500 8501 for key, value := range shape { 8502 switch key { 8503 case "DatasetGroups": 8504 if err := awsAwsjson11_deserializeDocumentDatasetGroups(&sv.DatasetGroups, value); err != nil { 8505 return err 8506 } 8507 8508 case "NextToken": 8509 if value != nil { 8510 jtv, ok := value.(string) 8511 if !ok { 8512 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8513 } 8514 sv.NextToken = ptr.String(jtv) 8515 } 8516 8517 default: 8518 _, _ = key, value 8519 8520 } 8521 } 8522 *v = sv 8523 return nil 8524} 8525 8526func awsAwsjson11_deserializeOpDocumentListDatasetImportJobsOutput(v **ListDatasetImportJobsOutput, value interface{}) error { 8527 if v == nil { 8528 return fmt.Errorf("unexpected nil of type %T", v) 8529 } 8530 if value == nil { 8531 return nil 8532 } 8533 8534 shape, ok := value.(map[string]interface{}) 8535 if !ok { 8536 return fmt.Errorf("unexpected JSON type %v", value) 8537 } 8538 8539 var sv *ListDatasetImportJobsOutput 8540 if *v == nil { 8541 sv = &ListDatasetImportJobsOutput{} 8542 } else { 8543 sv = *v 8544 } 8545 8546 for key, value := range shape { 8547 switch key { 8548 case "DatasetImportJobs": 8549 if err := awsAwsjson11_deserializeDocumentDatasetImportJobs(&sv.DatasetImportJobs, value); err != nil { 8550 return err 8551 } 8552 8553 case "NextToken": 8554 if value != nil { 8555 jtv, ok := value.(string) 8556 if !ok { 8557 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8558 } 8559 sv.NextToken = ptr.String(jtv) 8560 } 8561 8562 default: 8563 _, _ = key, value 8564 8565 } 8566 } 8567 *v = sv 8568 return nil 8569} 8570 8571func awsAwsjson11_deserializeOpDocumentListDatasetsOutput(v **ListDatasetsOutput, value interface{}) error { 8572 if v == nil { 8573 return fmt.Errorf("unexpected nil of type %T", v) 8574 } 8575 if value == nil { 8576 return nil 8577 } 8578 8579 shape, ok := value.(map[string]interface{}) 8580 if !ok { 8581 return fmt.Errorf("unexpected JSON type %v", value) 8582 } 8583 8584 var sv *ListDatasetsOutput 8585 if *v == nil { 8586 sv = &ListDatasetsOutput{} 8587 } else { 8588 sv = *v 8589 } 8590 8591 for key, value := range shape { 8592 switch key { 8593 case "Datasets": 8594 if err := awsAwsjson11_deserializeDocumentDatasets(&sv.Datasets, value); err != nil { 8595 return err 8596 } 8597 8598 case "NextToken": 8599 if value != nil { 8600 jtv, ok := value.(string) 8601 if !ok { 8602 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8603 } 8604 sv.NextToken = ptr.String(jtv) 8605 } 8606 8607 default: 8608 _, _ = key, value 8609 8610 } 8611 } 8612 *v = sv 8613 return nil 8614} 8615 8616func awsAwsjson11_deserializeOpDocumentListForecastExportJobsOutput(v **ListForecastExportJobsOutput, value interface{}) error { 8617 if v == nil { 8618 return fmt.Errorf("unexpected nil of type %T", v) 8619 } 8620 if value == nil { 8621 return nil 8622 } 8623 8624 shape, ok := value.(map[string]interface{}) 8625 if !ok { 8626 return fmt.Errorf("unexpected JSON type %v", value) 8627 } 8628 8629 var sv *ListForecastExportJobsOutput 8630 if *v == nil { 8631 sv = &ListForecastExportJobsOutput{} 8632 } else { 8633 sv = *v 8634 } 8635 8636 for key, value := range shape { 8637 switch key { 8638 case "ForecastExportJobs": 8639 if err := awsAwsjson11_deserializeDocumentForecastExportJobs(&sv.ForecastExportJobs, value); err != nil { 8640 return err 8641 } 8642 8643 case "NextToken": 8644 if value != nil { 8645 jtv, ok := value.(string) 8646 if !ok { 8647 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8648 } 8649 sv.NextToken = ptr.String(jtv) 8650 } 8651 8652 default: 8653 _, _ = key, value 8654 8655 } 8656 } 8657 *v = sv 8658 return nil 8659} 8660 8661func awsAwsjson11_deserializeOpDocumentListForecastsOutput(v **ListForecastsOutput, value interface{}) error { 8662 if v == nil { 8663 return fmt.Errorf("unexpected nil of type %T", v) 8664 } 8665 if value == nil { 8666 return nil 8667 } 8668 8669 shape, ok := value.(map[string]interface{}) 8670 if !ok { 8671 return fmt.Errorf("unexpected JSON type %v", value) 8672 } 8673 8674 var sv *ListForecastsOutput 8675 if *v == nil { 8676 sv = &ListForecastsOutput{} 8677 } else { 8678 sv = *v 8679 } 8680 8681 for key, value := range shape { 8682 switch key { 8683 case "Forecasts": 8684 if err := awsAwsjson11_deserializeDocumentForecasts(&sv.Forecasts, value); err != nil { 8685 return err 8686 } 8687 8688 case "NextToken": 8689 if value != nil { 8690 jtv, ok := value.(string) 8691 if !ok { 8692 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8693 } 8694 sv.NextToken = ptr.String(jtv) 8695 } 8696 8697 default: 8698 _, _ = key, value 8699 8700 } 8701 } 8702 *v = sv 8703 return nil 8704} 8705 8706func awsAwsjson11_deserializeOpDocumentListPredictorBacktestExportJobsOutput(v **ListPredictorBacktestExportJobsOutput, value interface{}) error { 8707 if v == nil { 8708 return fmt.Errorf("unexpected nil of type %T", v) 8709 } 8710 if value == nil { 8711 return nil 8712 } 8713 8714 shape, ok := value.(map[string]interface{}) 8715 if !ok { 8716 return fmt.Errorf("unexpected JSON type %v", value) 8717 } 8718 8719 var sv *ListPredictorBacktestExportJobsOutput 8720 if *v == nil { 8721 sv = &ListPredictorBacktestExportJobsOutput{} 8722 } else { 8723 sv = *v 8724 } 8725 8726 for key, value := range shape { 8727 switch key { 8728 case "NextToken": 8729 if value != nil { 8730 jtv, ok := value.(string) 8731 if !ok { 8732 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8733 } 8734 sv.NextToken = ptr.String(jtv) 8735 } 8736 8737 case "PredictorBacktestExportJobs": 8738 if err := awsAwsjson11_deserializeDocumentPredictorBacktestExportJobs(&sv.PredictorBacktestExportJobs, value); err != nil { 8739 return err 8740 } 8741 8742 default: 8743 _, _ = key, value 8744 8745 } 8746 } 8747 *v = sv 8748 return nil 8749} 8750 8751func awsAwsjson11_deserializeOpDocumentListPredictorsOutput(v **ListPredictorsOutput, value interface{}) error { 8752 if v == nil { 8753 return fmt.Errorf("unexpected nil of type %T", v) 8754 } 8755 if value == nil { 8756 return nil 8757 } 8758 8759 shape, ok := value.(map[string]interface{}) 8760 if !ok { 8761 return fmt.Errorf("unexpected JSON type %v", value) 8762 } 8763 8764 var sv *ListPredictorsOutput 8765 if *v == nil { 8766 sv = &ListPredictorsOutput{} 8767 } else { 8768 sv = *v 8769 } 8770 8771 for key, value := range shape { 8772 switch key { 8773 case "NextToken": 8774 if value != nil { 8775 jtv, ok := value.(string) 8776 if !ok { 8777 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8778 } 8779 sv.NextToken = ptr.String(jtv) 8780 } 8781 8782 case "Predictors": 8783 if err := awsAwsjson11_deserializeDocumentPredictors(&sv.Predictors, value); err != nil { 8784 return err 8785 } 8786 8787 default: 8788 _, _ = key, value 8789 8790 } 8791 } 8792 *v = sv 8793 return nil 8794} 8795 8796func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 8797 if v == nil { 8798 return fmt.Errorf("unexpected nil of type %T", v) 8799 } 8800 if value == nil { 8801 return nil 8802 } 8803 8804 shape, ok := value.(map[string]interface{}) 8805 if !ok { 8806 return fmt.Errorf("unexpected JSON type %v", value) 8807 } 8808 8809 var sv *ListTagsForResourceOutput 8810 if *v == nil { 8811 sv = &ListTagsForResourceOutput{} 8812 } else { 8813 sv = *v 8814 } 8815 8816 for key, value := range shape { 8817 switch key { 8818 case "Tags": 8819 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 8820 return err 8821 } 8822 8823 default: 8824 _, _ = key, value 8825 8826 } 8827 } 8828 *v = sv 8829 return nil 8830} 8831 8832func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 8833 if v == nil { 8834 return fmt.Errorf("unexpected nil of type %T", v) 8835 } 8836 if value == nil { 8837 return nil 8838 } 8839 8840 shape, ok := value.(map[string]interface{}) 8841 if !ok { 8842 return fmt.Errorf("unexpected JSON type %v", value) 8843 } 8844 8845 var sv *TagResourceOutput 8846 if *v == nil { 8847 sv = &TagResourceOutput{} 8848 } else { 8849 sv = *v 8850 } 8851 8852 for key, value := range shape { 8853 switch key { 8854 default: 8855 _, _ = key, value 8856 8857 } 8858 } 8859 *v = sv 8860 return nil 8861} 8862 8863func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 8864 if v == nil { 8865 return fmt.Errorf("unexpected nil of type %T", v) 8866 } 8867 if value == nil { 8868 return nil 8869 } 8870 8871 shape, ok := value.(map[string]interface{}) 8872 if !ok { 8873 return fmt.Errorf("unexpected JSON type %v", value) 8874 } 8875 8876 var sv *UntagResourceOutput 8877 if *v == nil { 8878 sv = &UntagResourceOutput{} 8879 } else { 8880 sv = *v 8881 } 8882 8883 for key, value := range shape { 8884 switch key { 8885 default: 8886 _, _ = key, value 8887 8888 } 8889 } 8890 *v = sv 8891 return nil 8892} 8893 8894func awsAwsjson11_deserializeOpDocumentUpdateDatasetGroupOutput(v **UpdateDatasetGroupOutput, value interface{}) error { 8895 if v == nil { 8896 return fmt.Errorf("unexpected nil of type %T", v) 8897 } 8898 if value == nil { 8899 return nil 8900 } 8901 8902 shape, ok := value.(map[string]interface{}) 8903 if !ok { 8904 return fmt.Errorf("unexpected JSON type %v", value) 8905 } 8906 8907 var sv *UpdateDatasetGroupOutput 8908 if *v == nil { 8909 sv = &UpdateDatasetGroupOutput{} 8910 } else { 8911 sv = *v 8912 } 8913 8914 for key, value := range shape { 8915 switch key { 8916 default: 8917 _, _ = key, value 8918 8919 } 8920 } 8921 *v = sv 8922 return nil 8923} 8924