1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package datasync 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/datasync/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 "strings" 20) 21 22type awsAwsjson11_deserializeOpCancelTaskExecution struct { 23} 24 25func (*awsAwsjson11_deserializeOpCancelTaskExecution) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpCancelTaskExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorCancelTaskExecution(response, &metadata) 44 } 45 output := &CancelTaskExecutionOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentCancelTaskExecutionOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorCancelTaskExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("InternalException", errorCode): 121 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 122 123 case strings.EqualFold("InvalidRequestException", errorCode): 124 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 125 126 default: 127 genericError := &smithy.GenericAPIError{ 128 Code: errorCode, 129 Message: errorMessage, 130 } 131 return genericError 132 133 } 134} 135 136type awsAwsjson11_deserializeOpCreateAgent struct { 137} 138 139func (*awsAwsjson11_deserializeOpCreateAgent) ID() string { 140 return "OperationDeserializer" 141} 142 143func (m *awsAwsjson11_deserializeOpCreateAgent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 144 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 145) { 146 out, metadata, err = next.HandleDeserialize(ctx, in) 147 if err != nil { 148 return out, metadata, err 149 } 150 151 response, ok := out.RawResponse.(*smithyhttp.Response) 152 if !ok { 153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 154 } 155 156 if response.StatusCode < 200 || response.StatusCode >= 300 { 157 return out, metadata, awsAwsjson11_deserializeOpErrorCreateAgent(response, &metadata) 158 } 159 output := &CreateAgentOutput{} 160 out.Result = output 161 162 var buff [1024]byte 163 ringBuffer := smithyio.NewRingBuffer(buff[:]) 164 165 body := io.TeeReader(response.Body, ringBuffer) 166 decoder := json.NewDecoder(body) 167 decoder.UseNumber() 168 var shape interface{} 169 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 170 var snapshot bytes.Buffer 171 io.Copy(&snapshot, ringBuffer) 172 err = &smithy.DeserializationError{ 173 Err: fmt.Errorf("failed to decode response body, %w", err), 174 Snapshot: snapshot.Bytes(), 175 } 176 return out, metadata, err 177 } 178 179 err = awsAwsjson11_deserializeOpDocumentCreateAgentOutput(&output, shape) 180 if err != nil { 181 var snapshot bytes.Buffer 182 io.Copy(&snapshot, ringBuffer) 183 err = &smithy.DeserializationError{ 184 Err: fmt.Errorf("failed to decode response body, %w", err), 185 Snapshot: snapshot.Bytes(), 186 } 187 return out, metadata, err 188 } 189 190 return out, metadata, err 191} 192 193func awsAwsjson11_deserializeOpErrorCreateAgent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 194 var errorBuffer bytes.Buffer 195 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 196 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 197 } 198 errorBody := bytes.NewReader(errorBuffer.Bytes()) 199 200 errorCode := "UnknownError" 201 errorMessage := errorCode 202 203 code := response.Header.Get("X-Amzn-ErrorType") 204 if len(code) != 0 { 205 errorCode = restjson.SanitizeErrorCode(code) 206 } 207 208 var buff [1024]byte 209 ringBuffer := smithyio.NewRingBuffer(buff[:]) 210 211 body := io.TeeReader(errorBody, ringBuffer) 212 decoder := json.NewDecoder(body) 213 decoder.UseNumber() 214 code, message, err := restjson.GetErrorInfo(decoder) 215 if err != nil { 216 var snapshot bytes.Buffer 217 io.Copy(&snapshot, ringBuffer) 218 err = &smithy.DeserializationError{ 219 Err: fmt.Errorf("failed to decode response body, %w", err), 220 Snapshot: snapshot.Bytes(), 221 } 222 return err 223 } 224 225 errorBody.Seek(0, io.SeekStart) 226 if len(code) != 0 { 227 errorCode = restjson.SanitizeErrorCode(code) 228 } 229 if len(message) != 0 { 230 errorMessage = message 231 } 232 233 switch { 234 case strings.EqualFold("InternalException", errorCode): 235 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 236 237 case strings.EqualFold("InvalidRequestException", errorCode): 238 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 239 240 default: 241 genericError := &smithy.GenericAPIError{ 242 Code: errorCode, 243 Message: errorMessage, 244 } 245 return genericError 246 247 } 248} 249 250type awsAwsjson11_deserializeOpCreateLocationEfs struct { 251} 252 253func (*awsAwsjson11_deserializeOpCreateLocationEfs) ID() string { 254 return "OperationDeserializer" 255} 256 257func (m *awsAwsjson11_deserializeOpCreateLocationEfs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 258 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 259) { 260 out, metadata, err = next.HandleDeserialize(ctx, in) 261 if err != nil { 262 return out, metadata, err 263 } 264 265 response, ok := out.RawResponse.(*smithyhttp.Response) 266 if !ok { 267 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 268 } 269 270 if response.StatusCode < 200 || response.StatusCode >= 300 { 271 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLocationEfs(response, &metadata) 272 } 273 output := &CreateLocationEfsOutput{} 274 out.Result = output 275 276 var buff [1024]byte 277 ringBuffer := smithyio.NewRingBuffer(buff[:]) 278 279 body := io.TeeReader(response.Body, ringBuffer) 280 decoder := json.NewDecoder(body) 281 decoder.UseNumber() 282 var shape interface{} 283 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 284 var snapshot bytes.Buffer 285 io.Copy(&snapshot, ringBuffer) 286 err = &smithy.DeserializationError{ 287 Err: fmt.Errorf("failed to decode response body, %w", err), 288 Snapshot: snapshot.Bytes(), 289 } 290 return out, metadata, err 291 } 292 293 err = awsAwsjson11_deserializeOpDocumentCreateLocationEfsOutput(&output, shape) 294 if err != nil { 295 var snapshot bytes.Buffer 296 io.Copy(&snapshot, ringBuffer) 297 err = &smithy.DeserializationError{ 298 Err: fmt.Errorf("failed to decode response body, %w", err), 299 Snapshot: snapshot.Bytes(), 300 } 301 return out, metadata, err 302 } 303 304 return out, metadata, err 305} 306 307func awsAwsjson11_deserializeOpErrorCreateLocationEfs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 308 var errorBuffer bytes.Buffer 309 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 310 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 311 } 312 errorBody := bytes.NewReader(errorBuffer.Bytes()) 313 314 errorCode := "UnknownError" 315 errorMessage := errorCode 316 317 code := response.Header.Get("X-Amzn-ErrorType") 318 if len(code) != 0 { 319 errorCode = restjson.SanitizeErrorCode(code) 320 } 321 322 var buff [1024]byte 323 ringBuffer := smithyio.NewRingBuffer(buff[:]) 324 325 body := io.TeeReader(errorBody, ringBuffer) 326 decoder := json.NewDecoder(body) 327 decoder.UseNumber() 328 code, message, err := restjson.GetErrorInfo(decoder) 329 if err != nil { 330 var snapshot bytes.Buffer 331 io.Copy(&snapshot, ringBuffer) 332 err = &smithy.DeserializationError{ 333 Err: fmt.Errorf("failed to decode response body, %w", err), 334 Snapshot: snapshot.Bytes(), 335 } 336 return err 337 } 338 339 errorBody.Seek(0, io.SeekStart) 340 if len(code) != 0 { 341 errorCode = restjson.SanitizeErrorCode(code) 342 } 343 if len(message) != 0 { 344 errorMessage = message 345 } 346 347 switch { 348 case strings.EqualFold("InternalException", errorCode): 349 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 350 351 case strings.EqualFold("InvalidRequestException", errorCode): 352 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 353 354 default: 355 genericError := &smithy.GenericAPIError{ 356 Code: errorCode, 357 Message: errorMessage, 358 } 359 return genericError 360 361 } 362} 363 364type awsAwsjson11_deserializeOpCreateLocationFsxWindows struct { 365} 366 367func (*awsAwsjson11_deserializeOpCreateLocationFsxWindows) ID() string { 368 return "OperationDeserializer" 369} 370 371func (m *awsAwsjson11_deserializeOpCreateLocationFsxWindows) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 372 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 373) { 374 out, metadata, err = next.HandleDeserialize(ctx, in) 375 if err != nil { 376 return out, metadata, err 377 } 378 379 response, ok := out.RawResponse.(*smithyhttp.Response) 380 if !ok { 381 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 382 } 383 384 if response.StatusCode < 200 || response.StatusCode >= 300 { 385 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLocationFsxWindows(response, &metadata) 386 } 387 output := &CreateLocationFsxWindowsOutput{} 388 out.Result = output 389 390 var buff [1024]byte 391 ringBuffer := smithyio.NewRingBuffer(buff[:]) 392 393 body := io.TeeReader(response.Body, ringBuffer) 394 decoder := json.NewDecoder(body) 395 decoder.UseNumber() 396 var shape interface{} 397 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 398 var snapshot bytes.Buffer 399 io.Copy(&snapshot, ringBuffer) 400 err = &smithy.DeserializationError{ 401 Err: fmt.Errorf("failed to decode response body, %w", err), 402 Snapshot: snapshot.Bytes(), 403 } 404 return out, metadata, err 405 } 406 407 err = awsAwsjson11_deserializeOpDocumentCreateLocationFsxWindowsOutput(&output, shape) 408 if err != nil { 409 var snapshot bytes.Buffer 410 io.Copy(&snapshot, ringBuffer) 411 err = &smithy.DeserializationError{ 412 Err: fmt.Errorf("failed to decode response body, %w", err), 413 Snapshot: snapshot.Bytes(), 414 } 415 return out, metadata, err 416 } 417 418 return out, metadata, err 419} 420 421func awsAwsjson11_deserializeOpErrorCreateLocationFsxWindows(response *smithyhttp.Response, metadata *middleware.Metadata) error { 422 var errorBuffer bytes.Buffer 423 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 424 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 425 } 426 errorBody := bytes.NewReader(errorBuffer.Bytes()) 427 428 errorCode := "UnknownError" 429 errorMessage := errorCode 430 431 code := response.Header.Get("X-Amzn-ErrorType") 432 if len(code) != 0 { 433 errorCode = restjson.SanitizeErrorCode(code) 434 } 435 436 var buff [1024]byte 437 ringBuffer := smithyio.NewRingBuffer(buff[:]) 438 439 body := io.TeeReader(errorBody, ringBuffer) 440 decoder := json.NewDecoder(body) 441 decoder.UseNumber() 442 code, message, err := restjson.GetErrorInfo(decoder) 443 if err != nil { 444 var snapshot bytes.Buffer 445 io.Copy(&snapshot, ringBuffer) 446 err = &smithy.DeserializationError{ 447 Err: fmt.Errorf("failed to decode response body, %w", err), 448 Snapshot: snapshot.Bytes(), 449 } 450 return err 451 } 452 453 errorBody.Seek(0, io.SeekStart) 454 if len(code) != 0 { 455 errorCode = restjson.SanitizeErrorCode(code) 456 } 457 if len(message) != 0 { 458 errorMessage = message 459 } 460 461 switch { 462 case strings.EqualFold("InternalException", errorCode): 463 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 464 465 case strings.EqualFold("InvalidRequestException", errorCode): 466 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 467 468 default: 469 genericError := &smithy.GenericAPIError{ 470 Code: errorCode, 471 Message: errorMessage, 472 } 473 return genericError 474 475 } 476} 477 478type awsAwsjson11_deserializeOpCreateLocationNfs struct { 479} 480 481func (*awsAwsjson11_deserializeOpCreateLocationNfs) ID() string { 482 return "OperationDeserializer" 483} 484 485func (m *awsAwsjson11_deserializeOpCreateLocationNfs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 486 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 487) { 488 out, metadata, err = next.HandleDeserialize(ctx, in) 489 if err != nil { 490 return out, metadata, err 491 } 492 493 response, ok := out.RawResponse.(*smithyhttp.Response) 494 if !ok { 495 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 496 } 497 498 if response.StatusCode < 200 || response.StatusCode >= 300 { 499 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLocationNfs(response, &metadata) 500 } 501 output := &CreateLocationNfsOutput{} 502 out.Result = output 503 504 var buff [1024]byte 505 ringBuffer := smithyio.NewRingBuffer(buff[:]) 506 507 body := io.TeeReader(response.Body, ringBuffer) 508 decoder := json.NewDecoder(body) 509 decoder.UseNumber() 510 var shape interface{} 511 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 512 var snapshot bytes.Buffer 513 io.Copy(&snapshot, ringBuffer) 514 err = &smithy.DeserializationError{ 515 Err: fmt.Errorf("failed to decode response body, %w", err), 516 Snapshot: snapshot.Bytes(), 517 } 518 return out, metadata, err 519 } 520 521 err = awsAwsjson11_deserializeOpDocumentCreateLocationNfsOutput(&output, shape) 522 if err != nil { 523 var snapshot bytes.Buffer 524 io.Copy(&snapshot, ringBuffer) 525 err = &smithy.DeserializationError{ 526 Err: fmt.Errorf("failed to decode response body, %w", err), 527 Snapshot: snapshot.Bytes(), 528 } 529 return out, metadata, err 530 } 531 532 return out, metadata, err 533} 534 535func awsAwsjson11_deserializeOpErrorCreateLocationNfs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 536 var errorBuffer bytes.Buffer 537 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 538 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 539 } 540 errorBody := bytes.NewReader(errorBuffer.Bytes()) 541 542 errorCode := "UnknownError" 543 errorMessage := errorCode 544 545 code := response.Header.Get("X-Amzn-ErrorType") 546 if len(code) != 0 { 547 errorCode = restjson.SanitizeErrorCode(code) 548 } 549 550 var buff [1024]byte 551 ringBuffer := smithyio.NewRingBuffer(buff[:]) 552 553 body := io.TeeReader(errorBody, ringBuffer) 554 decoder := json.NewDecoder(body) 555 decoder.UseNumber() 556 code, message, err := restjson.GetErrorInfo(decoder) 557 if err != nil { 558 var snapshot bytes.Buffer 559 io.Copy(&snapshot, ringBuffer) 560 err = &smithy.DeserializationError{ 561 Err: fmt.Errorf("failed to decode response body, %w", err), 562 Snapshot: snapshot.Bytes(), 563 } 564 return err 565 } 566 567 errorBody.Seek(0, io.SeekStart) 568 if len(code) != 0 { 569 errorCode = restjson.SanitizeErrorCode(code) 570 } 571 if len(message) != 0 { 572 errorMessage = message 573 } 574 575 switch { 576 case strings.EqualFold("InternalException", errorCode): 577 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 578 579 case strings.EqualFold("InvalidRequestException", errorCode): 580 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 581 582 default: 583 genericError := &smithy.GenericAPIError{ 584 Code: errorCode, 585 Message: errorMessage, 586 } 587 return genericError 588 589 } 590} 591 592type awsAwsjson11_deserializeOpCreateLocationObjectStorage struct { 593} 594 595func (*awsAwsjson11_deserializeOpCreateLocationObjectStorage) ID() string { 596 return "OperationDeserializer" 597} 598 599func (m *awsAwsjson11_deserializeOpCreateLocationObjectStorage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 600 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 601) { 602 out, metadata, err = next.HandleDeserialize(ctx, in) 603 if err != nil { 604 return out, metadata, err 605 } 606 607 response, ok := out.RawResponse.(*smithyhttp.Response) 608 if !ok { 609 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 610 } 611 612 if response.StatusCode < 200 || response.StatusCode >= 300 { 613 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLocationObjectStorage(response, &metadata) 614 } 615 output := &CreateLocationObjectStorageOutput{} 616 out.Result = output 617 618 var buff [1024]byte 619 ringBuffer := smithyio.NewRingBuffer(buff[:]) 620 621 body := io.TeeReader(response.Body, ringBuffer) 622 decoder := json.NewDecoder(body) 623 decoder.UseNumber() 624 var shape interface{} 625 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 626 var snapshot bytes.Buffer 627 io.Copy(&snapshot, ringBuffer) 628 err = &smithy.DeserializationError{ 629 Err: fmt.Errorf("failed to decode response body, %w", err), 630 Snapshot: snapshot.Bytes(), 631 } 632 return out, metadata, err 633 } 634 635 err = awsAwsjson11_deserializeOpDocumentCreateLocationObjectStorageOutput(&output, shape) 636 if err != nil { 637 var snapshot bytes.Buffer 638 io.Copy(&snapshot, ringBuffer) 639 err = &smithy.DeserializationError{ 640 Err: fmt.Errorf("failed to decode response body, %w", err), 641 Snapshot: snapshot.Bytes(), 642 } 643 return out, metadata, err 644 } 645 646 return out, metadata, err 647} 648 649func awsAwsjson11_deserializeOpErrorCreateLocationObjectStorage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 650 var errorBuffer bytes.Buffer 651 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 652 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 653 } 654 errorBody := bytes.NewReader(errorBuffer.Bytes()) 655 656 errorCode := "UnknownError" 657 errorMessage := errorCode 658 659 code := response.Header.Get("X-Amzn-ErrorType") 660 if len(code) != 0 { 661 errorCode = restjson.SanitizeErrorCode(code) 662 } 663 664 var buff [1024]byte 665 ringBuffer := smithyio.NewRingBuffer(buff[:]) 666 667 body := io.TeeReader(errorBody, ringBuffer) 668 decoder := json.NewDecoder(body) 669 decoder.UseNumber() 670 code, message, err := restjson.GetErrorInfo(decoder) 671 if err != nil { 672 var snapshot bytes.Buffer 673 io.Copy(&snapshot, ringBuffer) 674 err = &smithy.DeserializationError{ 675 Err: fmt.Errorf("failed to decode response body, %w", err), 676 Snapshot: snapshot.Bytes(), 677 } 678 return err 679 } 680 681 errorBody.Seek(0, io.SeekStart) 682 if len(code) != 0 { 683 errorCode = restjson.SanitizeErrorCode(code) 684 } 685 if len(message) != 0 { 686 errorMessage = message 687 } 688 689 switch { 690 case strings.EqualFold("InternalException", errorCode): 691 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 692 693 case strings.EqualFold("InvalidRequestException", errorCode): 694 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 695 696 default: 697 genericError := &smithy.GenericAPIError{ 698 Code: errorCode, 699 Message: errorMessage, 700 } 701 return genericError 702 703 } 704} 705 706type awsAwsjson11_deserializeOpCreateLocationS3 struct { 707} 708 709func (*awsAwsjson11_deserializeOpCreateLocationS3) ID() string { 710 return "OperationDeserializer" 711} 712 713func (m *awsAwsjson11_deserializeOpCreateLocationS3) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 714 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 715) { 716 out, metadata, err = next.HandleDeserialize(ctx, in) 717 if err != nil { 718 return out, metadata, err 719 } 720 721 response, ok := out.RawResponse.(*smithyhttp.Response) 722 if !ok { 723 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 724 } 725 726 if response.StatusCode < 200 || response.StatusCode >= 300 { 727 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLocationS3(response, &metadata) 728 } 729 output := &CreateLocationS3Output{} 730 out.Result = output 731 732 var buff [1024]byte 733 ringBuffer := smithyio.NewRingBuffer(buff[:]) 734 735 body := io.TeeReader(response.Body, ringBuffer) 736 decoder := json.NewDecoder(body) 737 decoder.UseNumber() 738 var shape interface{} 739 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 740 var snapshot bytes.Buffer 741 io.Copy(&snapshot, ringBuffer) 742 err = &smithy.DeserializationError{ 743 Err: fmt.Errorf("failed to decode response body, %w", err), 744 Snapshot: snapshot.Bytes(), 745 } 746 return out, metadata, err 747 } 748 749 err = awsAwsjson11_deserializeOpDocumentCreateLocationS3Output(&output, shape) 750 if err != nil { 751 var snapshot bytes.Buffer 752 io.Copy(&snapshot, ringBuffer) 753 err = &smithy.DeserializationError{ 754 Err: fmt.Errorf("failed to decode response body, %w", err), 755 Snapshot: snapshot.Bytes(), 756 } 757 return out, metadata, err 758 } 759 760 return out, metadata, err 761} 762 763func awsAwsjson11_deserializeOpErrorCreateLocationS3(response *smithyhttp.Response, metadata *middleware.Metadata) error { 764 var errorBuffer bytes.Buffer 765 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 766 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 767 } 768 errorBody := bytes.NewReader(errorBuffer.Bytes()) 769 770 errorCode := "UnknownError" 771 errorMessage := errorCode 772 773 code := response.Header.Get("X-Amzn-ErrorType") 774 if len(code) != 0 { 775 errorCode = restjson.SanitizeErrorCode(code) 776 } 777 778 var buff [1024]byte 779 ringBuffer := smithyio.NewRingBuffer(buff[:]) 780 781 body := io.TeeReader(errorBody, ringBuffer) 782 decoder := json.NewDecoder(body) 783 decoder.UseNumber() 784 code, message, err := restjson.GetErrorInfo(decoder) 785 if err != nil { 786 var snapshot bytes.Buffer 787 io.Copy(&snapshot, ringBuffer) 788 err = &smithy.DeserializationError{ 789 Err: fmt.Errorf("failed to decode response body, %w", err), 790 Snapshot: snapshot.Bytes(), 791 } 792 return err 793 } 794 795 errorBody.Seek(0, io.SeekStart) 796 if len(code) != 0 { 797 errorCode = restjson.SanitizeErrorCode(code) 798 } 799 if len(message) != 0 { 800 errorMessage = message 801 } 802 803 switch { 804 case strings.EqualFold("InternalException", errorCode): 805 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 806 807 case strings.EqualFold("InvalidRequestException", errorCode): 808 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 809 810 default: 811 genericError := &smithy.GenericAPIError{ 812 Code: errorCode, 813 Message: errorMessage, 814 } 815 return genericError 816 817 } 818} 819 820type awsAwsjson11_deserializeOpCreateLocationSmb struct { 821} 822 823func (*awsAwsjson11_deserializeOpCreateLocationSmb) ID() string { 824 return "OperationDeserializer" 825} 826 827func (m *awsAwsjson11_deserializeOpCreateLocationSmb) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 828 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 829) { 830 out, metadata, err = next.HandleDeserialize(ctx, in) 831 if err != nil { 832 return out, metadata, err 833 } 834 835 response, ok := out.RawResponse.(*smithyhttp.Response) 836 if !ok { 837 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 838 } 839 840 if response.StatusCode < 200 || response.StatusCode >= 300 { 841 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLocationSmb(response, &metadata) 842 } 843 output := &CreateLocationSmbOutput{} 844 out.Result = output 845 846 var buff [1024]byte 847 ringBuffer := smithyio.NewRingBuffer(buff[:]) 848 849 body := io.TeeReader(response.Body, ringBuffer) 850 decoder := json.NewDecoder(body) 851 decoder.UseNumber() 852 var shape interface{} 853 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 854 var snapshot bytes.Buffer 855 io.Copy(&snapshot, ringBuffer) 856 err = &smithy.DeserializationError{ 857 Err: fmt.Errorf("failed to decode response body, %w", err), 858 Snapshot: snapshot.Bytes(), 859 } 860 return out, metadata, err 861 } 862 863 err = awsAwsjson11_deserializeOpDocumentCreateLocationSmbOutput(&output, shape) 864 if err != nil { 865 var snapshot bytes.Buffer 866 io.Copy(&snapshot, ringBuffer) 867 err = &smithy.DeserializationError{ 868 Err: fmt.Errorf("failed to decode response body, %w", err), 869 Snapshot: snapshot.Bytes(), 870 } 871 return out, metadata, err 872 } 873 874 return out, metadata, err 875} 876 877func awsAwsjson11_deserializeOpErrorCreateLocationSmb(response *smithyhttp.Response, metadata *middleware.Metadata) error { 878 var errorBuffer bytes.Buffer 879 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 880 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 881 } 882 errorBody := bytes.NewReader(errorBuffer.Bytes()) 883 884 errorCode := "UnknownError" 885 errorMessage := errorCode 886 887 code := response.Header.Get("X-Amzn-ErrorType") 888 if len(code) != 0 { 889 errorCode = restjson.SanitizeErrorCode(code) 890 } 891 892 var buff [1024]byte 893 ringBuffer := smithyio.NewRingBuffer(buff[:]) 894 895 body := io.TeeReader(errorBody, ringBuffer) 896 decoder := json.NewDecoder(body) 897 decoder.UseNumber() 898 code, message, err := restjson.GetErrorInfo(decoder) 899 if err != nil { 900 var snapshot bytes.Buffer 901 io.Copy(&snapshot, ringBuffer) 902 err = &smithy.DeserializationError{ 903 Err: fmt.Errorf("failed to decode response body, %w", err), 904 Snapshot: snapshot.Bytes(), 905 } 906 return err 907 } 908 909 errorBody.Seek(0, io.SeekStart) 910 if len(code) != 0 { 911 errorCode = restjson.SanitizeErrorCode(code) 912 } 913 if len(message) != 0 { 914 errorMessage = message 915 } 916 917 switch { 918 case strings.EqualFold("InternalException", errorCode): 919 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 920 921 case strings.EqualFold("InvalidRequestException", errorCode): 922 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 923 924 default: 925 genericError := &smithy.GenericAPIError{ 926 Code: errorCode, 927 Message: errorMessage, 928 } 929 return genericError 930 931 } 932} 933 934type awsAwsjson11_deserializeOpCreateTask struct { 935} 936 937func (*awsAwsjson11_deserializeOpCreateTask) ID() string { 938 return "OperationDeserializer" 939} 940 941func (m *awsAwsjson11_deserializeOpCreateTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 942 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 943) { 944 out, metadata, err = next.HandleDeserialize(ctx, in) 945 if err != nil { 946 return out, metadata, err 947 } 948 949 response, ok := out.RawResponse.(*smithyhttp.Response) 950 if !ok { 951 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 952 } 953 954 if response.StatusCode < 200 || response.StatusCode >= 300 { 955 return out, metadata, awsAwsjson11_deserializeOpErrorCreateTask(response, &metadata) 956 } 957 output := &CreateTaskOutput{} 958 out.Result = output 959 960 var buff [1024]byte 961 ringBuffer := smithyio.NewRingBuffer(buff[:]) 962 963 body := io.TeeReader(response.Body, ringBuffer) 964 decoder := json.NewDecoder(body) 965 decoder.UseNumber() 966 var shape interface{} 967 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 968 var snapshot bytes.Buffer 969 io.Copy(&snapshot, ringBuffer) 970 err = &smithy.DeserializationError{ 971 Err: fmt.Errorf("failed to decode response body, %w", err), 972 Snapshot: snapshot.Bytes(), 973 } 974 return out, metadata, err 975 } 976 977 err = awsAwsjson11_deserializeOpDocumentCreateTaskOutput(&output, shape) 978 if err != nil { 979 var snapshot bytes.Buffer 980 io.Copy(&snapshot, ringBuffer) 981 err = &smithy.DeserializationError{ 982 Err: fmt.Errorf("failed to decode response body, %w", err), 983 Snapshot: snapshot.Bytes(), 984 } 985 return out, metadata, err 986 } 987 988 return out, metadata, err 989} 990 991func awsAwsjson11_deserializeOpErrorCreateTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 992 var errorBuffer bytes.Buffer 993 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 994 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 995 } 996 errorBody := bytes.NewReader(errorBuffer.Bytes()) 997 998 errorCode := "UnknownError" 999 errorMessage := errorCode 1000 1001 code := response.Header.Get("X-Amzn-ErrorType") 1002 if len(code) != 0 { 1003 errorCode = restjson.SanitizeErrorCode(code) 1004 } 1005 1006 var buff [1024]byte 1007 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1008 1009 body := io.TeeReader(errorBody, ringBuffer) 1010 decoder := json.NewDecoder(body) 1011 decoder.UseNumber() 1012 code, message, err := restjson.GetErrorInfo(decoder) 1013 if err != nil { 1014 var snapshot bytes.Buffer 1015 io.Copy(&snapshot, ringBuffer) 1016 err = &smithy.DeserializationError{ 1017 Err: fmt.Errorf("failed to decode response body, %w", err), 1018 Snapshot: snapshot.Bytes(), 1019 } 1020 return err 1021 } 1022 1023 errorBody.Seek(0, io.SeekStart) 1024 if len(code) != 0 { 1025 errorCode = restjson.SanitizeErrorCode(code) 1026 } 1027 if len(message) != 0 { 1028 errorMessage = message 1029 } 1030 1031 switch { 1032 case strings.EqualFold("InternalException", errorCode): 1033 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1034 1035 case strings.EqualFold("InvalidRequestException", errorCode): 1036 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1037 1038 default: 1039 genericError := &smithy.GenericAPIError{ 1040 Code: errorCode, 1041 Message: errorMessage, 1042 } 1043 return genericError 1044 1045 } 1046} 1047 1048type awsAwsjson11_deserializeOpDeleteAgent struct { 1049} 1050 1051func (*awsAwsjson11_deserializeOpDeleteAgent) ID() string { 1052 return "OperationDeserializer" 1053} 1054 1055func (m *awsAwsjson11_deserializeOpDeleteAgent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1056 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1057) { 1058 out, metadata, err = next.HandleDeserialize(ctx, in) 1059 if err != nil { 1060 return out, metadata, err 1061 } 1062 1063 response, ok := out.RawResponse.(*smithyhttp.Response) 1064 if !ok { 1065 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1066 } 1067 1068 if response.StatusCode < 200 || response.StatusCode >= 300 { 1069 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAgent(response, &metadata) 1070 } 1071 output := &DeleteAgentOutput{} 1072 out.Result = output 1073 1074 var buff [1024]byte 1075 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1076 1077 body := io.TeeReader(response.Body, ringBuffer) 1078 decoder := json.NewDecoder(body) 1079 decoder.UseNumber() 1080 var shape interface{} 1081 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1082 var snapshot bytes.Buffer 1083 io.Copy(&snapshot, ringBuffer) 1084 err = &smithy.DeserializationError{ 1085 Err: fmt.Errorf("failed to decode response body, %w", err), 1086 Snapshot: snapshot.Bytes(), 1087 } 1088 return out, metadata, err 1089 } 1090 1091 err = awsAwsjson11_deserializeOpDocumentDeleteAgentOutput(&output, shape) 1092 if err != nil { 1093 var snapshot bytes.Buffer 1094 io.Copy(&snapshot, ringBuffer) 1095 err = &smithy.DeserializationError{ 1096 Err: fmt.Errorf("failed to decode response body, %w", err), 1097 Snapshot: snapshot.Bytes(), 1098 } 1099 return out, metadata, err 1100 } 1101 1102 return out, metadata, err 1103} 1104 1105func awsAwsjson11_deserializeOpErrorDeleteAgent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1106 var errorBuffer bytes.Buffer 1107 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1108 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1109 } 1110 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1111 1112 errorCode := "UnknownError" 1113 errorMessage := errorCode 1114 1115 code := response.Header.Get("X-Amzn-ErrorType") 1116 if len(code) != 0 { 1117 errorCode = restjson.SanitizeErrorCode(code) 1118 } 1119 1120 var buff [1024]byte 1121 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1122 1123 body := io.TeeReader(errorBody, ringBuffer) 1124 decoder := json.NewDecoder(body) 1125 decoder.UseNumber() 1126 code, message, err := restjson.GetErrorInfo(decoder) 1127 if err != nil { 1128 var snapshot bytes.Buffer 1129 io.Copy(&snapshot, ringBuffer) 1130 err = &smithy.DeserializationError{ 1131 Err: fmt.Errorf("failed to decode response body, %w", err), 1132 Snapshot: snapshot.Bytes(), 1133 } 1134 return err 1135 } 1136 1137 errorBody.Seek(0, io.SeekStart) 1138 if len(code) != 0 { 1139 errorCode = restjson.SanitizeErrorCode(code) 1140 } 1141 if len(message) != 0 { 1142 errorMessage = message 1143 } 1144 1145 switch { 1146 case strings.EqualFold("InternalException", errorCode): 1147 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1148 1149 case strings.EqualFold("InvalidRequestException", errorCode): 1150 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1151 1152 default: 1153 genericError := &smithy.GenericAPIError{ 1154 Code: errorCode, 1155 Message: errorMessage, 1156 } 1157 return genericError 1158 1159 } 1160} 1161 1162type awsAwsjson11_deserializeOpDeleteLocation struct { 1163} 1164 1165func (*awsAwsjson11_deserializeOpDeleteLocation) ID() string { 1166 return "OperationDeserializer" 1167} 1168 1169func (m *awsAwsjson11_deserializeOpDeleteLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1170 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1171) { 1172 out, metadata, err = next.HandleDeserialize(ctx, in) 1173 if err != nil { 1174 return out, metadata, err 1175 } 1176 1177 response, ok := out.RawResponse.(*smithyhttp.Response) 1178 if !ok { 1179 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1180 } 1181 1182 if response.StatusCode < 200 || response.StatusCode >= 300 { 1183 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLocation(response, &metadata) 1184 } 1185 output := &DeleteLocationOutput{} 1186 out.Result = output 1187 1188 var buff [1024]byte 1189 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1190 1191 body := io.TeeReader(response.Body, ringBuffer) 1192 decoder := json.NewDecoder(body) 1193 decoder.UseNumber() 1194 var shape interface{} 1195 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1196 var snapshot bytes.Buffer 1197 io.Copy(&snapshot, ringBuffer) 1198 err = &smithy.DeserializationError{ 1199 Err: fmt.Errorf("failed to decode response body, %w", err), 1200 Snapshot: snapshot.Bytes(), 1201 } 1202 return out, metadata, err 1203 } 1204 1205 err = awsAwsjson11_deserializeOpDocumentDeleteLocationOutput(&output, shape) 1206 if err != nil { 1207 var snapshot bytes.Buffer 1208 io.Copy(&snapshot, ringBuffer) 1209 err = &smithy.DeserializationError{ 1210 Err: fmt.Errorf("failed to decode response body, %w", err), 1211 Snapshot: snapshot.Bytes(), 1212 } 1213 return out, metadata, err 1214 } 1215 1216 return out, metadata, err 1217} 1218 1219func awsAwsjson11_deserializeOpErrorDeleteLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1220 var errorBuffer bytes.Buffer 1221 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1222 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1223 } 1224 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1225 1226 errorCode := "UnknownError" 1227 errorMessage := errorCode 1228 1229 code := response.Header.Get("X-Amzn-ErrorType") 1230 if len(code) != 0 { 1231 errorCode = restjson.SanitizeErrorCode(code) 1232 } 1233 1234 var buff [1024]byte 1235 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1236 1237 body := io.TeeReader(errorBody, ringBuffer) 1238 decoder := json.NewDecoder(body) 1239 decoder.UseNumber() 1240 code, message, err := restjson.GetErrorInfo(decoder) 1241 if err != nil { 1242 var snapshot bytes.Buffer 1243 io.Copy(&snapshot, ringBuffer) 1244 err = &smithy.DeserializationError{ 1245 Err: fmt.Errorf("failed to decode response body, %w", err), 1246 Snapshot: snapshot.Bytes(), 1247 } 1248 return err 1249 } 1250 1251 errorBody.Seek(0, io.SeekStart) 1252 if len(code) != 0 { 1253 errorCode = restjson.SanitizeErrorCode(code) 1254 } 1255 if len(message) != 0 { 1256 errorMessage = message 1257 } 1258 1259 switch { 1260 case strings.EqualFold("InternalException", errorCode): 1261 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1262 1263 case strings.EqualFold("InvalidRequestException", errorCode): 1264 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1265 1266 default: 1267 genericError := &smithy.GenericAPIError{ 1268 Code: errorCode, 1269 Message: errorMessage, 1270 } 1271 return genericError 1272 1273 } 1274} 1275 1276type awsAwsjson11_deserializeOpDeleteTask struct { 1277} 1278 1279func (*awsAwsjson11_deserializeOpDeleteTask) ID() string { 1280 return "OperationDeserializer" 1281} 1282 1283func (m *awsAwsjson11_deserializeOpDeleteTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1284 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1285) { 1286 out, metadata, err = next.HandleDeserialize(ctx, in) 1287 if err != nil { 1288 return out, metadata, err 1289 } 1290 1291 response, ok := out.RawResponse.(*smithyhttp.Response) 1292 if !ok { 1293 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1294 } 1295 1296 if response.StatusCode < 200 || response.StatusCode >= 300 { 1297 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTask(response, &metadata) 1298 } 1299 output := &DeleteTaskOutput{} 1300 out.Result = output 1301 1302 var buff [1024]byte 1303 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1304 1305 body := io.TeeReader(response.Body, ringBuffer) 1306 decoder := json.NewDecoder(body) 1307 decoder.UseNumber() 1308 var shape interface{} 1309 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1310 var snapshot bytes.Buffer 1311 io.Copy(&snapshot, ringBuffer) 1312 err = &smithy.DeserializationError{ 1313 Err: fmt.Errorf("failed to decode response body, %w", err), 1314 Snapshot: snapshot.Bytes(), 1315 } 1316 return out, metadata, err 1317 } 1318 1319 err = awsAwsjson11_deserializeOpDocumentDeleteTaskOutput(&output, shape) 1320 if err != nil { 1321 var snapshot bytes.Buffer 1322 io.Copy(&snapshot, ringBuffer) 1323 err = &smithy.DeserializationError{ 1324 Err: fmt.Errorf("failed to decode response body, %w", err), 1325 Snapshot: snapshot.Bytes(), 1326 } 1327 return out, metadata, err 1328 } 1329 1330 return out, metadata, err 1331} 1332 1333func awsAwsjson11_deserializeOpErrorDeleteTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1334 var errorBuffer bytes.Buffer 1335 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1336 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1337 } 1338 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1339 1340 errorCode := "UnknownError" 1341 errorMessage := errorCode 1342 1343 code := response.Header.Get("X-Amzn-ErrorType") 1344 if len(code) != 0 { 1345 errorCode = restjson.SanitizeErrorCode(code) 1346 } 1347 1348 var buff [1024]byte 1349 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1350 1351 body := io.TeeReader(errorBody, ringBuffer) 1352 decoder := json.NewDecoder(body) 1353 decoder.UseNumber() 1354 code, message, err := restjson.GetErrorInfo(decoder) 1355 if err != nil { 1356 var snapshot bytes.Buffer 1357 io.Copy(&snapshot, ringBuffer) 1358 err = &smithy.DeserializationError{ 1359 Err: fmt.Errorf("failed to decode response body, %w", err), 1360 Snapshot: snapshot.Bytes(), 1361 } 1362 return err 1363 } 1364 1365 errorBody.Seek(0, io.SeekStart) 1366 if len(code) != 0 { 1367 errorCode = restjson.SanitizeErrorCode(code) 1368 } 1369 if len(message) != 0 { 1370 errorMessage = message 1371 } 1372 1373 switch { 1374 case strings.EqualFold("InternalException", errorCode): 1375 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1376 1377 case strings.EqualFold("InvalidRequestException", errorCode): 1378 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1379 1380 default: 1381 genericError := &smithy.GenericAPIError{ 1382 Code: errorCode, 1383 Message: errorMessage, 1384 } 1385 return genericError 1386 1387 } 1388} 1389 1390type awsAwsjson11_deserializeOpDescribeAgent struct { 1391} 1392 1393func (*awsAwsjson11_deserializeOpDescribeAgent) ID() string { 1394 return "OperationDeserializer" 1395} 1396 1397func (m *awsAwsjson11_deserializeOpDescribeAgent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1398 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1399) { 1400 out, metadata, err = next.HandleDeserialize(ctx, in) 1401 if err != nil { 1402 return out, metadata, err 1403 } 1404 1405 response, ok := out.RawResponse.(*smithyhttp.Response) 1406 if !ok { 1407 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1408 } 1409 1410 if response.StatusCode < 200 || response.StatusCode >= 300 { 1411 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAgent(response, &metadata) 1412 } 1413 output := &DescribeAgentOutput{} 1414 out.Result = output 1415 1416 var buff [1024]byte 1417 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1418 1419 body := io.TeeReader(response.Body, ringBuffer) 1420 decoder := json.NewDecoder(body) 1421 decoder.UseNumber() 1422 var shape interface{} 1423 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1424 var snapshot bytes.Buffer 1425 io.Copy(&snapshot, ringBuffer) 1426 err = &smithy.DeserializationError{ 1427 Err: fmt.Errorf("failed to decode response body, %w", err), 1428 Snapshot: snapshot.Bytes(), 1429 } 1430 return out, metadata, err 1431 } 1432 1433 err = awsAwsjson11_deserializeOpDocumentDescribeAgentOutput(&output, shape) 1434 if err != nil { 1435 var snapshot bytes.Buffer 1436 io.Copy(&snapshot, ringBuffer) 1437 err = &smithy.DeserializationError{ 1438 Err: fmt.Errorf("failed to decode response body, %w", err), 1439 Snapshot: snapshot.Bytes(), 1440 } 1441 return out, metadata, err 1442 } 1443 1444 return out, metadata, err 1445} 1446 1447func awsAwsjson11_deserializeOpErrorDescribeAgent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1448 var errorBuffer bytes.Buffer 1449 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1450 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1451 } 1452 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1453 1454 errorCode := "UnknownError" 1455 errorMessage := errorCode 1456 1457 code := response.Header.Get("X-Amzn-ErrorType") 1458 if len(code) != 0 { 1459 errorCode = restjson.SanitizeErrorCode(code) 1460 } 1461 1462 var buff [1024]byte 1463 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1464 1465 body := io.TeeReader(errorBody, ringBuffer) 1466 decoder := json.NewDecoder(body) 1467 decoder.UseNumber() 1468 code, message, err := restjson.GetErrorInfo(decoder) 1469 if err != nil { 1470 var snapshot bytes.Buffer 1471 io.Copy(&snapshot, ringBuffer) 1472 err = &smithy.DeserializationError{ 1473 Err: fmt.Errorf("failed to decode response body, %w", err), 1474 Snapshot: snapshot.Bytes(), 1475 } 1476 return err 1477 } 1478 1479 errorBody.Seek(0, io.SeekStart) 1480 if len(code) != 0 { 1481 errorCode = restjson.SanitizeErrorCode(code) 1482 } 1483 if len(message) != 0 { 1484 errorMessage = message 1485 } 1486 1487 switch { 1488 case strings.EqualFold("InternalException", errorCode): 1489 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1490 1491 case strings.EqualFold("InvalidRequestException", errorCode): 1492 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1493 1494 default: 1495 genericError := &smithy.GenericAPIError{ 1496 Code: errorCode, 1497 Message: errorMessage, 1498 } 1499 return genericError 1500 1501 } 1502} 1503 1504type awsAwsjson11_deserializeOpDescribeLocationEfs struct { 1505} 1506 1507func (*awsAwsjson11_deserializeOpDescribeLocationEfs) ID() string { 1508 return "OperationDeserializer" 1509} 1510 1511func (m *awsAwsjson11_deserializeOpDescribeLocationEfs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1512 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1513) { 1514 out, metadata, err = next.HandleDeserialize(ctx, in) 1515 if err != nil { 1516 return out, metadata, err 1517 } 1518 1519 response, ok := out.RawResponse.(*smithyhttp.Response) 1520 if !ok { 1521 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1522 } 1523 1524 if response.StatusCode < 200 || response.StatusCode >= 300 { 1525 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLocationEfs(response, &metadata) 1526 } 1527 output := &DescribeLocationEfsOutput{} 1528 out.Result = output 1529 1530 var buff [1024]byte 1531 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1532 1533 body := io.TeeReader(response.Body, ringBuffer) 1534 decoder := json.NewDecoder(body) 1535 decoder.UseNumber() 1536 var shape interface{} 1537 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1538 var snapshot bytes.Buffer 1539 io.Copy(&snapshot, ringBuffer) 1540 err = &smithy.DeserializationError{ 1541 Err: fmt.Errorf("failed to decode response body, %w", err), 1542 Snapshot: snapshot.Bytes(), 1543 } 1544 return out, metadata, err 1545 } 1546 1547 err = awsAwsjson11_deserializeOpDocumentDescribeLocationEfsOutput(&output, shape) 1548 if err != nil { 1549 var snapshot bytes.Buffer 1550 io.Copy(&snapshot, ringBuffer) 1551 err = &smithy.DeserializationError{ 1552 Err: fmt.Errorf("failed to decode response body, %w", err), 1553 Snapshot: snapshot.Bytes(), 1554 } 1555 return out, metadata, err 1556 } 1557 1558 return out, metadata, err 1559} 1560 1561func awsAwsjson11_deserializeOpErrorDescribeLocationEfs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1562 var errorBuffer bytes.Buffer 1563 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1564 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1565 } 1566 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1567 1568 errorCode := "UnknownError" 1569 errorMessage := errorCode 1570 1571 code := response.Header.Get("X-Amzn-ErrorType") 1572 if len(code) != 0 { 1573 errorCode = restjson.SanitizeErrorCode(code) 1574 } 1575 1576 var buff [1024]byte 1577 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1578 1579 body := io.TeeReader(errorBody, ringBuffer) 1580 decoder := json.NewDecoder(body) 1581 decoder.UseNumber() 1582 code, message, err := restjson.GetErrorInfo(decoder) 1583 if err != nil { 1584 var snapshot bytes.Buffer 1585 io.Copy(&snapshot, ringBuffer) 1586 err = &smithy.DeserializationError{ 1587 Err: fmt.Errorf("failed to decode response body, %w", err), 1588 Snapshot: snapshot.Bytes(), 1589 } 1590 return err 1591 } 1592 1593 errorBody.Seek(0, io.SeekStart) 1594 if len(code) != 0 { 1595 errorCode = restjson.SanitizeErrorCode(code) 1596 } 1597 if len(message) != 0 { 1598 errorMessage = message 1599 } 1600 1601 switch { 1602 case strings.EqualFold("InternalException", errorCode): 1603 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1604 1605 case strings.EqualFold("InvalidRequestException", errorCode): 1606 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1607 1608 default: 1609 genericError := &smithy.GenericAPIError{ 1610 Code: errorCode, 1611 Message: errorMessage, 1612 } 1613 return genericError 1614 1615 } 1616} 1617 1618type awsAwsjson11_deserializeOpDescribeLocationFsxWindows struct { 1619} 1620 1621func (*awsAwsjson11_deserializeOpDescribeLocationFsxWindows) ID() string { 1622 return "OperationDeserializer" 1623} 1624 1625func (m *awsAwsjson11_deserializeOpDescribeLocationFsxWindows) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1626 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1627) { 1628 out, metadata, err = next.HandleDeserialize(ctx, in) 1629 if err != nil { 1630 return out, metadata, err 1631 } 1632 1633 response, ok := out.RawResponse.(*smithyhttp.Response) 1634 if !ok { 1635 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1636 } 1637 1638 if response.StatusCode < 200 || response.StatusCode >= 300 { 1639 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLocationFsxWindows(response, &metadata) 1640 } 1641 output := &DescribeLocationFsxWindowsOutput{} 1642 out.Result = output 1643 1644 var buff [1024]byte 1645 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1646 1647 body := io.TeeReader(response.Body, ringBuffer) 1648 decoder := json.NewDecoder(body) 1649 decoder.UseNumber() 1650 var shape interface{} 1651 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1652 var snapshot bytes.Buffer 1653 io.Copy(&snapshot, ringBuffer) 1654 err = &smithy.DeserializationError{ 1655 Err: fmt.Errorf("failed to decode response body, %w", err), 1656 Snapshot: snapshot.Bytes(), 1657 } 1658 return out, metadata, err 1659 } 1660 1661 err = awsAwsjson11_deserializeOpDocumentDescribeLocationFsxWindowsOutput(&output, shape) 1662 if err != nil { 1663 var snapshot bytes.Buffer 1664 io.Copy(&snapshot, ringBuffer) 1665 err = &smithy.DeserializationError{ 1666 Err: fmt.Errorf("failed to decode response body, %w", err), 1667 Snapshot: snapshot.Bytes(), 1668 } 1669 return out, metadata, err 1670 } 1671 1672 return out, metadata, err 1673} 1674 1675func awsAwsjson11_deserializeOpErrorDescribeLocationFsxWindows(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1676 var errorBuffer bytes.Buffer 1677 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1678 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1679 } 1680 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1681 1682 errorCode := "UnknownError" 1683 errorMessage := errorCode 1684 1685 code := response.Header.Get("X-Amzn-ErrorType") 1686 if len(code) != 0 { 1687 errorCode = restjson.SanitizeErrorCode(code) 1688 } 1689 1690 var buff [1024]byte 1691 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1692 1693 body := io.TeeReader(errorBody, ringBuffer) 1694 decoder := json.NewDecoder(body) 1695 decoder.UseNumber() 1696 code, message, err := restjson.GetErrorInfo(decoder) 1697 if err != nil { 1698 var snapshot bytes.Buffer 1699 io.Copy(&snapshot, ringBuffer) 1700 err = &smithy.DeserializationError{ 1701 Err: fmt.Errorf("failed to decode response body, %w", err), 1702 Snapshot: snapshot.Bytes(), 1703 } 1704 return err 1705 } 1706 1707 errorBody.Seek(0, io.SeekStart) 1708 if len(code) != 0 { 1709 errorCode = restjson.SanitizeErrorCode(code) 1710 } 1711 if len(message) != 0 { 1712 errorMessage = message 1713 } 1714 1715 switch { 1716 case strings.EqualFold("InternalException", errorCode): 1717 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1718 1719 case strings.EqualFold("InvalidRequestException", errorCode): 1720 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1721 1722 default: 1723 genericError := &smithy.GenericAPIError{ 1724 Code: errorCode, 1725 Message: errorMessage, 1726 } 1727 return genericError 1728 1729 } 1730} 1731 1732type awsAwsjson11_deserializeOpDescribeLocationNfs struct { 1733} 1734 1735func (*awsAwsjson11_deserializeOpDescribeLocationNfs) ID() string { 1736 return "OperationDeserializer" 1737} 1738 1739func (m *awsAwsjson11_deserializeOpDescribeLocationNfs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1740 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1741) { 1742 out, metadata, err = next.HandleDeserialize(ctx, in) 1743 if err != nil { 1744 return out, metadata, err 1745 } 1746 1747 response, ok := out.RawResponse.(*smithyhttp.Response) 1748 if !ok { 1749 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1750 } 1751 1752 if response.StatusCode < 200 || response.StatusCode >= 300 { 1753 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLocationNfs(response, &metadata) 1754 } 1755 output := &DescribeLocationNfsOutput{} 1756 out.Result = output 1757 1758 var buff [1024]byte 1759 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1760 1761 body := io.TeeReader(response.Body, ringBuffer) 1762 decoder := json.NewDecoder(body) 1763 decoder.UseNumber() 1764 var shape interface{} 1765 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1766 var snapshot bytes.Buffer 1767 io.Copy(&snapshot, ringBuffer) 1768 err = &smithy.DeserializationError{ 1769 Err: fmt.Errorf("failed to decode response body, %w", err), 1770 Snapshot: snapshot.Bytes(), 1771 } 1772 return out, metadata, err 1773 } 1774 1775 err = awsAwsjson11_deserializeOpDocumentDescribeLocationNfsOutput(&output, shape) 1776 if err != nil { 1777 var snapshot bytes.Buffer 1778 io.Copy(&snapshot, ringBuffer) 1779 err = &smithy.DeserializationError{ 1780 Err: fmt.Errorf("failed to decode response body, %w", err), 1781 Snapshot: snapshot.Bytes(), 1782 } 1783 return out, metadata, err 1784 } 1785 1786 return out, metadata, err 1787} 1788 1789func awsAwsjson11_deserializeOpErrorDescribeLocationNfs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1790 var errorBuffer bytes.Buffer 1791 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1792 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1793 } 1794 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1795 1796 errorCode := "UnknownError" 1797 errorMessage := errorCode 1798 1799 code := response.Header.Get("X-Amzn-ErrorType") 1800 if len(code) != 0 { 1801 errorCode = restjson.SanitizeErrorCode(code) 1802 } 1803 1804 var buff [1024]byte 1805 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1806 1807 body := io.TeeReader(errorBody, ringBuffer) 1808 decoder := json.NewDecoder(body) 1809 decoder.UseNumber() 1810 code, message, err := restjson.GetErrorInfo(decoder) 1811 if err != nil { 1812 var snapshot bytes.Buffer 1813 io.Copy(&snapshot, ringBuffer) 1814 err = &smithy.DeserializationError{ 1815 Err: fmt.Errorf("failed to decode response body, %w", err), 1816 Snapshot: snapshot.Bytes(), 1817 } 1818 return err 1819 } 1820 1821 errorBody.Seek(0, io.SeekStart) 1822 if len(code) != 0 { 1823 errorCode = restjson.SanitizeErrorCode(code) 1824 } 1825 if len(message) != 0 { 1826 errorMessage = message 1827 } 1828 1829 switch { 1830 case strings.EqualFold("InternalException", errorCode): 1831 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1832 1833 case strings.EqualFold("InvalidRequestException", errorCode): 1834 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1835 1836 default: 1837 genericError := &smithy.GenericAPIError{ 1838 Code: errorCode, 1839 Message: errorMessage, 1840 } 1841 return genericError 1842 1843 } 1844} 1845 1846type awsAwsjson11_deserializeOpDescribeLocationObjectStorage struct { 1847} 1848 1849func (*awsAwsjson11_deserializeOpDescribeLocationObjectStorage) ID() string { 1850 return "OperationDeserializer" 1851} 1852 1853func (m *awsAwsjson11_deserializeOpDescribeLocationObjectStorage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1854 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1855) { 1856 out, metadata, err = next.HandleDeserialize(ctx, in) 1857 if err != nil { 1858 return out, metadata, err 1859 } 1860 1861 response, ok := out.RawResponse.(*smithyhttp.Response) 1862 if !ok { 1863 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1864 } 1865 1866 if response.StatusCode < 200 || response.StatusCode >= 300 { 1867 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLocationObjectStorage(response, &metadata) 1868 } 1869 output := &DescribeLocationObjectStorageOutput{} 1870 out.Result = output 1871 1872 var buff [1024]byte 1873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1874 1875 body := io.TeeReader(response.Body, ringBuffer) 1876 decoder := json.NewDecoder(body) 1877 decoder.UseNumber() 1878 var shape interface{} 1879 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1880 var snapshot bytes.Buffer 1881 io.Copy(&snapshot, ringBuffer) 1882 err = &smithy.DeserializationError{ 1883 Err: fmt.Errorf("failed to decode response body, %w", err), 1884 Snapshot: snapshot.Bytes(), 1885 } 1886 return out, metadata, err 1887 } 1888 1889 err = awsAwsjson11_deserializeOpDocumentDescribeLocationObjectStorageOutput(&output, shape) 1890 if err != nil { 1891 var snapshot bytes.Buffer 1892 io.Copy(&snapshot, ringBuffer) 1893 err = &smithy.DeserializationError{ 1894 Err: fmt.Errorf("failed to decode response body, %w", err), 1895 Snapshot: snapshot.Bytes(), 1896 } 1897 return out, metadata, err 1898 } 1899 1900 return out, metadata, err 1901} 1902 1903func awsAwsjson11_deserializeOpErrorDescribeLocationObjectStorage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1904 var errorBuffer bytes.Buffer 1905 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1906 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1907 } 1908 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1909 1910 errorCode := "UnknownError" 1911 errorMessage := errorCode 1912 1913 code := response.Header.Get("X-Amzn-ErrorType") 1914 if len(code) != 0 { 1915 errorCode = restjson.SanitizeErrorCode(code) 1916 } 1917 1918 var buff [1024]byte 1919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1920 1921 body := io.TeeReader(errorBody, ringBuffer) 1922 decoder := json.NewDecoder(body) 1923 decoder.UseNumber() 1924 code, message, err := restjson.GetErrorInfo(decoder) 1925 if err != nil { 1926 var snapshot bytes.Buffer 1927 io.Copy(&snapshot, ringBuffer) 1928 err = &smithy.DeserializationError{ 1929 Err: fmt.Errorf("failed to decode response body, %w", err), 1930 Snapshot: snapshot.Bytes(), 1931 } 1932 return err 1933 } 1934 1935 errorBody.Seek(0, io.SeekStart) 1936 if len(code) != 0 { 1937 errorCode = restjson.SanitizeErrorCode(code) 1938 } 1939 if len(message) != 0 { 1940 errorMessage = message 1941 } 1942 1943 switch { 1944 case strings.EqualFold("InternalException", errorCode): 1945 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 1946 1947 case strings.EqualFold("InvalidRequestException", errorCode): 1948 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1949 1950 default: 1951 genericError := &smithy.GenericAPIError{ 1952 Code: errorCode, 1953 Message: errorMessage, 1954 } 1955 return genericError 1956 1957 } 1958} 1959 1960type awsAwsjson11_deserializeOpDescribeLocationS3 struct { 1961} 1962 1963func (*awsAwsjson11_deserializeOpDescribeLocationS3) ID() string { 1964 return "OperationDeserializer" 1965} 1966 1967func (m *awsAwsjson11_deserializeOpDescribeLocationS3) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1968 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1969) { 1970 out, metadata, err = next.HandleDeserialize(ctx, in) 1971 if err != nil { 1972 return out, metadata, err 1973 } 1974 1975 response, ok := out.RawResponse.(*smithyhttp.Response) 1976 if !ok { 1977 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1978 } 1979 1980 if response.StatusCode < 200 || response.StatusCode >= 300 { 1981 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLocationS3(response, &metadata) 1982 } 1983 output := &DescribeLocationS3Output{} 1984 out.Result = output 1985 1986 var buff [1024]byte 1987 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1988 1989 body := io.TeeReader(response.Body, ringBuffer) 1990 decoder := json.NewDecoder(body) 1991 decoder.UseNumber() 1992 var shape interface{} 1993 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1994 var snapshot bytes.Buffer 1995 io.Copy(&snapshot, ringBuffer) 1996 err = &smithy.DeserializationError{ 1997 Err: fmt.Errorf("failed to decode response body, %w", err), 1998 Snapshot: snapshot.Bytes(), 1999 } 2000 return out, metadata, err 2001 } 2002 2003 err = awsAwsjson11_deserializeOpDocumentDescribeLocationS3Output(&output, shape) 2004 if err != nil { 2005 var snapshot bytes.Buffer 2006 io.Copy(&snapshot, ringBuffer) 2007 err = &smithy.DeserializationError{ 2008 Err: fmt.Errorf("failed to decode response body, %w", err), 2009 Snapshot: snapshot.Bytes(), 2010 } 2011 return out, metadata, err 2012 } 2013 2014 return out, metadata, err 2015} 2016 2017func awsAwsjson11_deserializeOpErrorDescribeLocationS3(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2018 var errorBuffer bytes.Buffer 2019 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2020 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2021 } 2022 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2023 2024 errorCode := "UnknownError" 2025 errorMessage := errorCode 2026 2027 code := response.Header.Get("X-Amzn-ErrorType") 2028 if len(code) != 0 { 2029 errorCode = restjson.SanitizeErrorCode(code) 2030 } 2031 2032 var buff [1024]byte 2033 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2034 2035 body := io.TeeReader(errorBody, ringBuffer) 2036 decoder := json.NewDecoder(body) 2037 decoder.UseNumber() 2038 code, message, err := restjson.GetErrorInfo(decoder) 2039 if err != nil { 2040 var snapshot bytes.Buffer 2041 io.Copy(&snapshot, ringBuffer) 2042 err = &smithy.DeserializationError{ 2043 Err: fmt.Errorf("failed to decode response body, %w", err), 2044 Snapshot: snapshot.Bytes(), 2045 } 2046 return err 2047 } 2048 2049 errorBody.Seek(0, io.SeekStart) 2050 if len(code) != 0 { 2051 errorCode = restjson.SanitizeErrorCode(code) 2052 } 2053 if len(message) != 0 { 2054 errorMessage = message 2055 } 2056 2057 switch { 2058 case strings.EqualFold("InternalException", errorCode): 2059 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2060 2061 case strings.EqualFold("InvalidRequestException", errorCode): 2062 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2063 2064 default: 2065 genericError := &smithy.GenericAPIError{ 2066 Code: errorCode, 2067 Message: errorMessage, 2068 } 2069 return genericError 2070 2071 } 2072} 2073 2074type awsAwsjson11_deserializeOpDescribeLocationSmb struct { 2075} 2076 2077func (*awsAwsjson11_deserializeOpDescribeLocationSmb) ID() string { 2078 return "OperationDeserializer" 2079} 2080 2081func (m *awsAwsjson11_deserializeOpDescribeLocationSmb) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2082 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2083) { 2084 out, metadata, err = next.HandleDeserialize(ctx, in) 2085 if err != nil { 2086 return out, metadata, err 2087 } 2088 2089 response, ok := out.RawResponse.(*smithyhttp.Response) 2090 if !ok { 2091 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2092 } 2093 2094 if response.StatusCode < 200 || response.StatusCode >= 300 { 2095 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLocationSmb(response, &metadata) 2096 } 2097 output := &DescribeLocationSmbOutput{} 2098 out.Result = output 2099 2100 var buff [1024]byte 2101 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2102 2103 body := io.TeeReader(response.Body, ringBuffer) 2104 decoder := json.NewDecoder(body) 2105 decoder.UseNumber() 2106 var shape interface{} 2107 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2108 var snapshot bytes.Buffer 2109 io.Copy(&snapshot, ringBuffer) 2110 err = &smithy.DeserializationError{ 2111 Err: fmt.Errorf("failed to decode response body, %w", err), 2112 Snapshot: snapshot.Bytes(), 2113 } 2114 return out, metadata, err 2115 } 2116 2117 err = awsAwsjson11_deserializeOpDocumentDescribeLocationSmbOutput(&output, shape) 2118 if err != nil { 2119 var snapshot bytes.Buffer 2120 io.Copy(&snapshot, ringBuffer) 2121 err = &smithy.DeserializationError{ 2122 Err: fmt.Errorf("failed to decode response body, %w", err), 2123 Snapshot: snapshot.Bytes(), 2124 } 2125 return out, metadata, err 2126 } 2127 2128 return out, metadata, err 2129} 2130 2131func awsAwsjson11_deserializeOpErrorDescribeLocationSmb(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2132 var errorBuffer bytes.Buffer 2133 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2134 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2135 } 2136 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2137 2138 errorCode := "UnknownError" 2139 errorMessage := errorCode 2140 2141 code := response.Header.Get("X-Amzn-ErrorType") 2142 if len(code) != 0 { 2143 errorCode = restjson.SanitizeErrorCode(code) 2144 } 2145 2146 var buff [1024]byte 2147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2148 2149 body := io.TeeReader(errorBody, ringBuffer) 2150 decoder := json.NewDecoder(body) 2151 decoder.UseNumber() 2152 code, message, err := restjson.GetErrorInfo(decoder) 2153 if err != nil { 2154 var snapshot bytes.Buffer 2155 io.Copy(&snapshot, ringBuffer) 2156 err = &smithy.DeserializationError{ 2157 Err: fmt.Errorf("failed to decode response body, %w", err), 2158 Snapshot: snapshot.Bytes(), 2159 } 2160 return err 2161 } 2162 2163 errorBody.Seek(0, io.SeekStart) 2164 if len(code) != 0 { 2165 errorCode = restjson.SanitizeErrorCode(code) 2166 } 2167 if len(message) != 0 { 2168 errorMessage = message 2169 } 2170 2171 switch { 2172 case strings.EqualFold("InternalException", errorCode): 2173 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2174 2175 case strings.EqualFold("InvalidRequestException", errorCode): 2176 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2177 2178 default: 2179 genericError := &smithy.GenericAPIError{ 2180 Code: errorCode, 2181 Message: errorMessage, 2182 } 2183 return genericError 2184 2185 } 2186} 2187 2188type awsAwsjson11_deserializeOpDescribeTask struct { 2189} 2190 2191func (*awsAwsjson11_deserializeOpDescribeTask) ID() string { 2192 return "OperationDeserializer" 2193} 2194 2195func (m *awsAwsjson11_deserializeOpDescribeTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2196 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2197) { 2198 out, metadata, err = next.HandleDeserialize(ctx, in) 2199 if err != nil { 2200 return out, metadata, err 2201 } 2202 2203 response, ok := out.RawResponse.(*smithyhttp.Response) 2204 if !ok { 2205 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2206 } 2207 2208 if response.StatusCode < 200 || response.StatusCode >= 300 { 2209 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTask(response, &metadata) 2210 } 2211 output := &DescribeTaskOutput{} 2212 out.Result = output 2213 2214 var buff [1024]byte 2215 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2216 2217 body := io.TeeReader(response.Body, ringBuffer) 2218 decoder := json.NewDecoder(body) 2219 decoder.UseNumber() 2220 var shape interface{} 2221 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2222 var snapshot bytes.Buffer 2223 io.Copy(&snapshot, ringBuffer) 2224 err = &smithy.DeserializationError{ 2225 Err: fmt.Errorf("failed to decode response body, %w", err), 2226 Snapshot: snapshot.Bytes(), 2227 } 2228 return out, metadata, err 2229 } 2230 2231 err = awsAwsjson11_deserializeOpDocumentDescribeTaskOutput(&output, shape) 2232 if err != nil { 2233 var snapshot bytes.Buffer 2234 io.Copy(&snapshot, ringBuffer) 2235 err = &smithy.DeserializationError{ 2236 Err: fmt.Errorf("failed to decode response body, %w", err), 2237 Snapshot: snapshot.Bytes(), 2238 } 2239 return out, metadata, err 2240 } 2241 2242 return out, metadata, err 2243} 2244 2245func awsAwsjson11_deserializeOpErrorDescribeTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2246 var errorBuffer bytes.Buffer 2247 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2248 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2249 } 2250 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2251 2252 errorCode := "UnknownError" 2253 errorMessage := errorCode 2254 2255 code := response.Header.Get("X-Amzn-ErrorType") 2256 if len(code) != 0 { 2257 errorCode = restjson.SanitizeErrorCode(code) 2258 } 2259 2260 var buff [1024]byte 2261 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2262 2263 body := io.TeeReader(errorBody, ringBuffer) 2264 decoder := json.NewDecoder(body) 2265 decoder.UseNumber() 2266 code, message, err := restjson.GetErrorInfo(decoder) 2267 if err != nil { 2268 var snapshot bytes.Buffer 2269 io.Copy(&snapshot, ringBuffer) 2270 err = &smithy.DeserializationError{ 2271 Err: fmt.Errorf("failed to decode response body, %w", err), 2272 Snapshot: snapshot.Bytes(), 2273 } 2274 return err 2275 } 2276 2277 errorBody.Seek(0, io.SeekStart) 2278 if len(code) != 0 { 2279 errorCode = restjson.SanitizeErrorCode(code) 2280 } 2281 if len(message) != 0 { 2282 errorMessage = message 2283 } 2284 2285 switch { 2286 case strings.EqualFold("InternalException", errorCode): 2287 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2288 2289 case strings.EqualFold("InvalidRequestException", errorCode): 2290 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2291 2292 default: 2293 genericError := &smithy.GenericAPIError{ 2294 Code: errorCode, 2295 Message: errorMessage, 2296 } 2297 return genericError 2298 2299 } 2300} 2301 2302type awsAwsjson11_deserializeOpDescribeTaskExecution struct { 2303} 2304 2305func (*awsAwsjson11_deserializeOpDescribeTaskExecution) ID() string { 2306 return "OperationDeserializer" 2307} 2308 2309func (m *awsAwsjson11_deserializeOpDescribeTaskExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2310 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2311) { 2312 out, metadata, err = next.HandleDeserialize(ctx, in) 2313 if err != nil { 2314 return out, metadata, err 2315 } 2316 2317 response, ok := out.RawResponse.(*smithyhttp.Response) 2318 if !ok { 2319 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2320 } 2321 2322 if response.StatusCode < 200 || response.StatusCode >= 300 { 2323 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTaskExecution(response, &metadata) 2324 } 2325 output := &DescribeTaskExecutionOutput{} 2326 out.Result = output 2327 2328 var buff [1024]byte 2329 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2330 2331 body := io.TeeReader(response.Body, ringBuffer) 2332 decoder := json.NewDecoder(body) 2333 decoder.UseNumber() 2334 var shape interface{} 2335 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2336 var snapshot bytes.Buffer 2337 io.Copy(&snapshot, ringBuffer) 2338 err = &smithy.DeserializationError{ 2339 Err: fmt.Errorf("failed to decode response body, %w", err), 2340 Snapshot: snapshot.Bytes(), 2341 } 2342 return out, metadata, err 2343 } 2344 2345 err = awsAwsjson11_deserializeOpDocumentDescribeTaskExecutionOutput(&output, shape) 2346 if err != nil { 2347 var snapshot bytes.Buffer 2348 io.Copy(&snapshot, ringBuffer) 2349 err = &smithy.DeserializationError{ 2350 Err: fmt.Errorf("failed to decode response body, %w", err), 2351 Snapshot: snapshot.Bytes(), 2352 } 2353 return out, metadata, err 2354 } 2355 2356 return out, metadata, err 2357} 2358 2359func awsAwsjson11_deserializeOpErrorDescribeTaskExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2360 var errorBuffer bytes.Buffer 2361 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2362 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2363 } 2364 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2365 2366 errorCode := "UnknownError" 2367 errorMessage := errorCode 2368 2369 code := response.Header.Get("X-Amzn-ErrorType") 2370 if len(code) != 0 { 2371 errorCode = restjson.SanitizeErrorCode(code) 2372 } 2373 2374 var buff [1024]byte 2375 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2376 2377 body := io.TeeReader(errorBody, ringBuffer) 2378 decoder := json.NewDecoder(body) 2379 decoder.UseNumber() 2380 code, message, err := restjson.GetErrorInfo(decoder) 2381 if err != nil { 2382 var snapshot bytes.Buffer 2383 io.Copy(&snapshot, ringBuffer) 2384 err = &smithy.DeserializationError{ 2385 Err: fmt.Errorf("failed to decode response body, %w", err), 2386 Snapshot: snapshot.Bytes(), 2387 } 2388 return err 2389 } 2390 2391 errorBody.Seek(0, io.SeekStart) 2392 if len(code) != 0 { 2393 errorCode = restjson.SanitizeErrorCode(code) 2394 } 2395 if len(message) != 0 { 2396 errorMessage = message 2397 } 2398 2399 switch { 2400 case strings.EqualFold("InternalException", errorCode): 2401 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2402 2403 case strings.EqualFold("InvalidRequestException", errorCode): 2404 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2405 2406 default: 2407 genericError := &smithy.GenericAPIError{ 2408 Code: errorCode, 2409 Message: errorMessage, 2410 } 2411 return genericError 2412 2413 } 2414} 2415 2416type awsAwsjson11_deserializeOpListAgents struct { 2417} 2418 2419func (*awsAwsjson11_deserializeOpListAgents) ID() string { 2420 return "OperationDeserializer" 2421} 2422 2423func (m *awsAwsjson11_deserializeOpListAgents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2424 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2425) { 2426 out, metadata, err = next.HandleDeserialize(ctx, in) 2427 if err != nil { 2428 return out, metadata, err 2429 } 2430 2431 response, ok := out.RawResponse.(*smithyhttp.Response) 2432 if !ok { 2433 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2434 } 2435 2436 if response.StatusCode < 200 || response.StatusCode >= 300 { 2437 return out, metadata, awsAwsjson11_deserializeOpErrorListAgents(response, &metadata) 2438 } 2439 output := &ListAgentsOutput{} 2440 out.Result = output 2441 2442 var buff [1024]byte 2443 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2444 2445 body := io.TeeReader(response.Body, ringBuffer) 2446 decoder := json.NewDecoder(body) 2447 decoder.UseNumber() 2448 var shape interface{} 2449 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2450 var snapshot bytes.Buffer 2451 io.Copy(&snapshot, ringBuffer) 2452 err = &smithy.DeserializationError{ 2453 Err: fmt.Errorf("failed to decode response body, %w", err), 2454 Snapshot: snapshot.Bytes(), 2455 } 2456 return out, metadata, err 2457 } 2458 2459 err = awsAwsjson11_deserializeOpDocumentListAgentsOutput(&output, shape) 2460 if err != nil { 2461 var snapshot bytes.Buffer 2462 io.Copy(&snapshot, ringBuffer) 2463 err = &smithy.DeserializationError{ 2464 Err: fmt.Errorf("failed to decode response body, %w", err), 2465 Snapshot: snapshot.Bytes(), 2466 } 2467 return out, metadata, err 2468 } 2469 2470 return out, metadata, err 2471} 2472 2473func awsAwsjson11_deserializeOpErrorListAgents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2474 var errorBuffer bytes.Buffer 2475 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2476 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2477 } 2478 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2479 2480 errorCode := "UnknownError" 2481 errorMessage := errorCode 2482 2483 code := response.Header.Get("X-Amzn-ErrorType") 2484 if len(code) != 0 { 2485 errorCode = restjson.SanitizeErrorCode(code) 2486 } 2487 2488 var buff [1024]byte 2489 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2490 2491 body := io.TeeReader(errorBody, ringBuffer) 2492 decoder := json.NewDecoder(body) 2493 decoder.UseNumber() 2494 code, message, err := restjson.GetErrorInfo(decoder) 2495 if err != nil { 2496 var snapshot bytes.Buffer 2497 io.Copy(&snapshot, ringBuffer) 2498 err = &smithy.DeserializationError{ 2499 Err: fmt.Errorf("failed to decode response body, %w", err), 2500 Snapshot: snapshot.Bytes(), 2501 } 2502 return err 2503 } 2504 2505 errorBody.Seek(0, io.SeekStart) 2506 if len(code) != 0 { 2507 errorCode = restjson.SanitizeErrorCode(code) 2508 } 2509 if len(message) != 0 { 2510 errorMessage = message 2511 } 2512 2513 switch { 2514 case strings.EqualFold("InternalException", errorCode): 2515 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2516 2517 case strings.EqualFold("InvalidRequestException", errorCode): 2518 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2519 2520 default: 2521 genericError := &smithy.GenericAPIError{ 2522 Code: errorCode, 2523 Message: errorMessage, 2524 } 2525 return genericError 2526 2527 } 2528} 2529 2530type awsAwsjson11_deserializeOpListLocations struct { 2531} 2532 2533func (*awsAwsjson11_deserializeOpListLocations) ID() string { 2534 return "OperationDeserializer" 2535} 2536 2537func (m *awsAwsjson11_deserializeOpListLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2538 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2539) { 2540 out, metadata, err = next.HandleDeserialize(ctx, in) 2541 if err != nil { 2542 return out, metadata, err 2543 } 2544 2545 response, ok := out.RawResponse.(*smithyhttp.Response) 2546 if !ok { 2547 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2548 } 2549 2550 if response.StatusCode < 200 || response.StatusCode >= 300 { 2551 return out, metadata, awsAwsjson11_deserializeOpErrorListLocations(response, &metadata) 2552 } 2553 output := &ListLocationsOutput{} 2554 out.Result = output 2555 2556 var buff [1024]byte 2557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2558 2559 body := io.TeeReader(response.Body, ringBuffer) 2560 decoder := json.NewDecoder(body) 2561 decoder.UseNumber() 2562 var shape interface{} 2563 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2564 var snapshot bytes.Buffer 2565 io.Copy(&snapshot, ringBuffer) 2566 err = &smithy.DeserializationError{ 2567 Err: fmt.Errorf("failed to decode response body, %w", err), 2568 Snapshot: snapshot.Bytes(), 2569 } 2570 return out, metadata, err 2571 } 2572 2573 err = awsAwsjson11_deserializeOpDocumentListLocationsOutput(&output, shape) 2574 if err != nil { 2575 var snapshot bytes.Buffer 2576 io.Copy(&snapshot, ringBuffer) 2577 err = &smithy.DeserializationError{ 2578 Err: fmt.Errorf("failed to decode response body, %w", err), 2579 Snapshot: snapshot.Bytes(), 2580 } 2581 return out, metadata, err 2582 } 2583 2584 return out, metadata, err 2585} 2586 2587func awsAwsjson11_deserializeOpErrorListLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2588 var errorBuffer bytes.Buffer 2589 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2590 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2591 } 2592 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2593 2594 errorCode := "UnknownError" 2595 errorMessage := errorCode 2596 2597 code := response.Header.Get("X-Amzn-ErrorType") 2598 if len(code) != 0 { 2599 errorCode = restjson.SanitizeErrorCode(code) 2600 } 2601 2602 var buff [1024]byte 2603 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2604 2605 body := io.TeeReader(errorBody, ringBuffer) 2606 decoder := json.NewDecoder(body) 2607 decoder.UseNumber() 2608 code, message, err := restjson.GetErrorInfo(decoder) 2609 if err != nil { 2610 var snapshot bytes.Buffer 2611 io.Copy(&snapshot, ringBuffer) 2612 err = &smithy.DeserializationError{ 2613 Err: fmt.Errorf("failed to decode response body, %w", err), 2614 Snapshot: snapshot.Bytes(), 2615 } 2616 return err 2617 } 2618 2619 errorBody.Seek(0, io.SeekStart) 2620 if len(code) != 0 { 2621 errorCode = restjson.SanitizeErrorCode(code) 2622 } 2623 if len(message) != 0 { 2624 errorMessage = message 2625 } 2626 2627 switch { 2628 case strings.EqualFold("InternalException", errorCode): 2629 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2630 2631 case strings.EqualFold("InvalidRequestException", errorCode): 2632 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2633 2634 default: 2635 genericError := &smithy.GenericAPIError{ 2636 Code: errorCode, 2637 Message: errorMessage, 2638 } 2639 return genericError 2640 2641 } 2642} 2643 2644type awsAwsjson11_deserializeOpListTagsForResource struct { 2645} 2646 2647func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 2648 return "OperationDeserializer" 2649} 2650 2651func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2652 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2653) { 2654 out, metadata, err = next.HandleDeserialize(ctx, in) 2655 if err != nil { 2656 return out, metadata, err 2657 } 2658 2659 response, ok := out.RawResponse.(*smithyhttp.Response) 2660 if !ok { 2661 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2662 } 2663 2664 if response.StatusCode < 200 || response.StatusCode >= 300 { 2665 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 2666 } 2667 output := &ListTagsForResourceOutput{} 2668 out.Result = output 2669 2670 var buff [1024]byte 2671 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2672 2673 body := io.TeeReader(response.Body, ringBuffer) 2674 decoder := json.NewDecoder(body) 2675 decoder.UseNumber() 2676 var shape interface{} 2677 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2678 var snapshot bytes.Buffer 2679 io.Copy(&snapshot, ringBuffer) 2680 err = &smithy.DeserializationError{ 2681 Err: fmt.Errorf("failed to decode response body, %w", err), 2682 Snapshot: snapshot.Bytes(), 2683 } 2684 return out, metadata, err 2685 } 2686 2687 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2688 if err != nil { 2689 var snapshot bytes.Buffer 2690 io.Copy(&snapshot, ringBuffer) 2691 err = &smithy.DeserializationError{ 2692 Err: fmt.Errorf("failed to decode response body, %w", err), 2693 Snapshot: snapshot.Bytes(), 2694 } 2695 return out, metadata, err 2696 } 2697 2698 return out, metadata, err 2699} 2700 2701func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2702 var errorBuffer bytes.Buffer 2703 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2704 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2705 } 2706 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2707 2708 errorCode := "UnknownError" 2709 errorMessage := errorCode 2710 2711 code := response.Header.Get("X-Amzn-ErrorType") 2712 if len(code) != 0 { 2713 errorCode = restjson.SanitizeErrorCode(code) 2714 } 2715 2716 var buff [1024]byte 2717 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2718 2719 body := io.TeeReader(errorBody, ringBuffer) 2720 decoder := json.NewDecoder(body) 2721 decoder.UseNumber() 2722 code, message, err := restjson.GetErrorInfo(decoder) 2723 if err != nil { 2724 var snapshot bytes.Buffer 2725 io.Copy(&snapshot, ringBuffer) 2726 err = &smithy.DeserializationError{ 2727 Err: fmt.Errorf("failed to decode response body, %w", err), 2728 Snapshot: snapshot.Bytes(), 2729 } 2730 return err 2731 } 2732 2733 errorBody.Seek(0, io.SeekStart) 2734 if len(code) != 0 { 2735 errorCode = restjson.SanitizeErrorCode(code) 2736 } 2737 if len(message) != 0 { 2738 errorMessage = message 2739 } 2740 2741 switch { 2742 case strings.EqualFold("InternalException", errorCode): 2743 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2744 2745 case strings.EqualFold("InvalidRequestException", errorCode): 2746 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2747 2748 default: 2749 genericError := &smithy.GenericAPIError{ 2750 Code: errorCode, 2751 Message: errorMessage, 2752 } 2753 return genericError 2754 2755 } 2756} 2757 2758type awsAwsjson11_deserializeOpListTaskExecutions struct { 2759} 2760 2761func (*awsAwsjson11_deserializeOpListTaskExecutions) ID() string { 2762 return "OperationDeserializer" 2763} 2764 2765func (m *awsAwsjson11_deserializeOpListTaskExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2766 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2767) { 2768 out, metadata, err = next.HandleDeserialize(ctx, in) 2769 if err != nil { 2770 return out, metadata, err 2771 } 2772 2773 response, ok := out.RawResponse.(*smithyhttp.Response) 2774 if !ok { 2775 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2776 } 2777 2778 if response.StatusCode < 200 || response.StatusCode >= 300 { 2779 return out, metadata, awsAwsjson11_deserializeOpErrorListTaskExecutions(response, &metadata) 2780 } 2781 output := &ListTaskExecutionsOutput{} 2782 out.Result = output 2783 2784 var buff [1024]byte 2785 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2786 2787 body := io.TeeReader(response.Body, ringBuffer) 2788 decoder := json.NewDecoder(body) 2789 decoder.UseNumber() 2790 var shape interface{} 2791 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2792 var snapshot bytes.Buffer 2793 io.Copy(&snapshot, ringBuffer) 2794 err = &smithy.DeserializationError{ 2795 Err: fmt.Errorf("failed to decode response body, %w", err), 2796 Snapshot: snapshot.Bytes(), 2797 } 2798 return out, metadata, err 2799 } 2800 2801 err = awsAwsjson11_deserializeOpDocumentListTaskExecutionsOutput(&output, shape) 2802 if err != nil { 2803 var snapshot bytes.Buffer 2804 io.Copy(&snapshot, ringBuffer) 2805 err = &smithy.DeserializationError{ 2806 Err: fmt.Errorf("failed to decode response body, %w", err), 2807 Snapshot: snapshot.Bytes(), 2808 } 2809 return out, metadata, err 2810 } 2811 2812 return out, metadata, err 2813} 2814 2815func awsAwsjson11_deserializeOpErrorListTaskExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2816 var errorBuffer bytes.Buffer 2817 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2818 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2819 } 2820 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2821 2822 errorCode := "UnknownError" 2823 errorMessage := errorCode 2824 2825 code := response.Header.Get("X-Amzn-ErrorType") 2826 if len(code) != 0 { 2827 errorCode = restjson.SanitizeErrorCode(code) 2828 } 2829 2830 var buff [1024]byte 2831 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2832 2833 body := io.TeeReader(errorBody, ringBuffer) 2834 decoder := json.NewDecoder(body) 2835 decoder.UseNumber() 2836 code, message, err := restjson.GetErrorInfo(decoder) 2837 if err != nil { 2838 var snapshot bytes.Buffer 2839 io.Copy(&snapshot, ringBuffer) 2840 err = &smithy.DeserializationError{ 2841 Err: fmt.Errorf("failed to decode response body, %w", err), 2842 Snapshot: snapshot.Bytes(), 2843 } 2844 return err 2845 } 2846 2847 errorBody.Seek(0, io.SeekStart) 2848 if len(code) != 0 { 2849 errorCode = restjson.SanitizeErrorCode(code) 2850 } 2851 if len(message) != 0 { 2852 errorMessage = message 2853 } 2854 2855 switch { 2856 case strings.EqualFold("InternalException", errorCode): 2857 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2858 2859 case strings.EqualFold("InvalidRequestException", errorCode): 2860 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2861 2862 default: 2863 genericError := &smithy.GenericAPIError{ 2864 Code: errorCode, 2865 Message: errorMessage, 2866 } 2867 return genericError 2868 2869 } 2870} 2871 2872type awsAwsjson11_deserializeOpListTasks struct { 2873} 2874 2875func (*awsAwsjson11_deserializeOpListTasks) ID() string { 2876 return "OperationDeserializer" 2877} 2878 2879func (m *awsAwsjson11_deserializeOpListTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2880 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2881) { 2882 out, metadata, err = next.HandleDeserialize(ctx, in) 2883 if err != nil { 2884 return out, metadata, err 2885 } 2886 2887 response, ok := out.RawResponse.(*smithyhttp.Response) 2888 if !ok { 2889 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2890 } 2891 2892 if response.StatusCode < 200 || response.StatusCode >= 300 { 2893 return out, metadata, awsAwsjson11_deserializeOpErrorListTasks(response, &metadata) 2894 } 2895 output := &ListTasksOutput{} 2896 out.Result = output 2897 2898 var buff [1024]byte 2899 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2900 2901 body := io.TeeReader(response.Body, ringBuffer) 2902 decoder := json.NewDecoder(body) 2903 decoder.UseNumber() 2904 var shape interface{} 2905 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2906 var snapshot bytes.Buffer 2907 io.Copy(&snapshot, ringBuffer) 2908 err = &smithy.DeserializationError{ 2909 Err: fmt.Errorf("failed to decode response body, %w", err), 2910 Snapshot: snapshot.Bytes(), 2911 } 2912 return out, metadata, err 2913 } 2914 2915 err = awsAwsjson11_deserializeOpDocumentListTasksOutput(&output, shape) 2916 if err != nil { 2917 var snapshot bytes.Buffer 2918 io.Copy(&snapshot, ringBuffer) 2919 err = &smithy.DeserializationError{ 2920 Err: fmt.Errorf("failed to decode response body, %w", err), 2921 Snapshot: snapshot.Bytes(), 2922 } 2923 return out, metadata, err 2924 } 2925 2926 return out, metadata, err 2927} 2928 2929func awsAwsjson11_deserializeOpErrorListTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2930 var errorBuffer bytes.Buffer 2931 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2932 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2933 } 2934 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2935 2936 errorCode := "UnknownError" 2937 errorMessage := errorCode 2938 2939 code := response.Header.Get("X-Amzn-ErrorType") 2940 if len(code) != 0 { 2941 errorCode = restjson.SanitizeErrorCode(code) 2942 } 2943 2944 var buff [1024]byte 2945 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2946 2947 body := io.TeeReader(errorBody, ringBuffer) 2948 decoder := json.NewDecoder(body) 2949 decoder.UseNumber() 2950 code, message, err := restjson.GetErrorInfo(decoder) 2951 if err != nil { 2952 var snapshot bytes.Buffer 2953 io.Copy(&snapshot, ringBuffer) 2954 err = &smithy.DeserializationError{ 2955 Err: fmt.Errorf("failed to decode response body, %w", err), 2956 Snapshot: snapshot.Bytes(), 2957 } 2958 return err 2959 } 2960 2961 errorBody.Seek(0, io.SeekStart) 2962 if len(code) != 0 { 2963 errorCode = restjson.SanitizeErrorCode(code) 2964 } 2965 if len(message) != 0 { 2966 errorMessage = message 2967 } 2968 2969 switch { 2970 case strings.EqualFold("InternalException", errorCode): 2971 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 2972 2973 case strings.EqualFold("InvalidRequestException", errorCode): 2974 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2975 2976 default: 2977 genericError := &smithy.GenericAPIError{ 2978 Code: errorCode, 2979 Message: errorMessage, 2980 } 2981 return genericError 2982 2983 } 2984} 2985 2986type awsAwsjson11_deserializeOpStartTaskExecution struct { 2987} 2988 2989func (*awsAwsjson11_deserializeOpStartTaskExecution) ID() string { 2990 return "OperationDeserializer" 2991} 2992 2993func (m *awsAwsjson11_deserializeOpStartTaskExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2994 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2995) { 2996 out, metadata, err = next.HandleDeserialize(ctx, in) 2997 if err != nil { 2998 return out, metadata, err 2999 } 3000 3001 response, ok := out.RawResponse.(*smithyhttp.Response) 3002 if !ok { 3003 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3004 } 3005 3006 if response.StatusCode < 200 || response.StatusCode >= 300 { 3007 return out, metadata, awsAwsjson11_deserializeOpErrorStartTaskExecution(response, &metadata) 3008 } 3009 output := &StartTaskExecutionOutput{} 3010 out.Result = output 3011 3012 var buff [1024]byte 3013 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3014 3015 body := io.TeeReader(response.Body, ringBuffer) 3016 decoder := json.NewDecoder(body) 3017 decoder.UseNumber() 3018 var shape interface{} 3019 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3020 var snapshot bytes.Buffer 3021 io.Copy(&snapshot, ringBuffer) 3022 err = &smithy.DeserializationError{ 3023 Err: fmt.Errorf("failed to decode response body, %w", err), 3024 Snapshot: snapshot.Bytes(), 3025 } 3026 return out, metadata, err 3027 } 3028 3029 err = awsAwsjson11_deserializeOpDocumentStartTaskExecutionOutput(&output, shape) 3030 if err != nil { 3031 var snapshot bytes.Buffer 3032 io.Copy(&snapshot, ringBuffer) 3033 err = &smithy.DeserializationError{ 3034 Err: fmt.Errorf("failed to decode response body, %w", err), 3035 Snapshot: snapshot.Bytes(), 3036 } 3037 return out, metadata, err 3038 } 3039 3040 return out, metadata, err 3041} 3042 3043func awsAwsjson11_deserializeOpErrorStartTaskExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3044 var errorBuffer bytes.Buffer 3045 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3046 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3047 } 3048 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3049 3050 errorCode := "UnknownError" 3051 errorMessage := errorCode 3052 3053 code := response.Header.Get("X-Amzn-ErrorType") 3054 if len(code) != 0 { 3055 errorCode = restjson.SanitizeErrorCode(code) 3056 } 3057 3058 var buff [1024]byte 3059 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3060 3061 body := io.TeeReader(errorBody, ringBuffer) 3062 decoder := json.NewDecoder(body) 3063 decoder.UseNumber() 3064 code, message, err := restjson.GetErrorInfo(decoder) 3065 if err != nil { 3066 var snapshot bytes.Buffer 3067 io.Copy(&snapshot, ringBuffer) 3068 err = &smithy.DeserializationError{ 3069 Err: fmt.Errorf("failed to decode response body, %w", err), 3070 Snapshot: snapshot.Bytes(), 3071 } 3072 return err 3073 } 3074 3075 errorBody.Seek(0, io.SeekStart) 3076 if len(code) != 0 { 3077 errorCode = restjson.SanitizeErrorCode(code) 3078 } 3079 if len(message) != 0 { 3080 errorMessage = message 3081 } 3082 3083 switch { 3084 case strings.EqualFold("InternalException", errorCode): 3085 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3086 3087 case strings.EqualFold("InvalidRequestException", errorCode): 3088 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3089 3090 default: 3091 genericError := &smithy.GenericAPIError{ 3092 Code: errorCode, 3093 Message: errorMessage, 3094 } 3095 return genericError 3096 3097 } 3098} 3099 3100type awsAwsjson11_deserializeOpTagResource struct { 3101} 3102 3103func (*awsAwsjson11_deserializeOpTagResource) ID() string { 3104 return "OperationDeserializer" 3105} 3106 3107func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3108 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3109) { 3110 out, metadata, err = next.HandleDeserialize(ctx, in) 3111 if err != nil { 3112 return out, metadata, err 3113 } 3114 3115 response, ok := out.RawResponse.(*smithyhttp.Response) 3116 if !ok { 3117 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3118 } 3119 3120 if response.StatusCode < 200 || response.StatusCode >= 300 { 3121 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 3122 } 3123 output := &TagResourceOutput{} 3124 out.Result = output 3125 3126 var buff [1024]byte 3127 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3128 3129 body := io.TeeReader(response.Body, ringBuffer) 3130 decoder := json.NewDecoder(body) 3131 decoder.UseNumber() 3132 var shape interface{} 3133 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3134 var snapshot bytes.Buffer 3135 io.Copy(&snapshot, ringBuffer) 3136 err = &smithy.DeserializationError{ 3137 Err: fmt.Errorf("failed to decode response body, %w", err), 3138 Snapshot: snapshot.Bytes(), 3139 } 3140 return out, metadata, err 3141 } 3142 3143 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 3144 if err != nil { 3145 var snapshot bytes.Buffer 3146 io.Copy(&snapshot, ringBuffer) 3147 err = &smithy.DeserializationError{ 3148 Err: fmt.Errorf("failed to decode response body, %w", err), 3149 Snapshot: snapshot.Bytes(), 3150 } 3151 return out, metadata, err 3152 } 3153 3154 return out, metadata, err 3155} 3156 3157func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3158 var errorBuffer bytes.Buffer 3159 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3160 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3161 } 3162 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3163 3164 errorCode := "UnknownError" 3165 errorMessage := errorCode 3166 3167 code := response.Header.Get("X-Amzn-ErrorType") 3168 if len(code) != 0 { 3169 errorCode = restjson.SanitizeErrorCode(code) 3170 } 3171 3172 var buff [1024]byte 3173 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3174 3175 body := io.TeeReader(errorBody, ringBuffer) 3176 decoder := json.NewDecoder(body) 3177 decoder.UseNumber() 3178 code, message, err := restjson.GetErrorInfo(decoder) 3179 if err != nil { 3180 var snapshot bytes.Buffer 3181 io.Copy(&snapshot, ringBuffer) 3182 err = &smithy.DeserializationError{ 3183 Err: fmt.Errorf("failed to decode response body, %w", err), 3184 Snapshot: snapshot.Bytes(), 3185 } 3186 return err 3187 } 3188 3189 errorBody.Seek(0, io.SeekStart) 3190 if len(code) != 0 { 3191 errorCode = restjson.SanitizeErrorCode(code) 3192 } 3193 if len(message) != 0 { 3194 errorMessage = message 3195 } 3196 3197 switch { 3198 case strings.EqualFold("InternalException", errorCode): 3199 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3200 3201 case strings.EqualFold("InvalidRequestException", errorCode): 3202 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3203 3204 default: 3205 genericError := &smithy.GenericAPIError{ 3206 Code: errorCode, 3207 Message: errorMessage, 3208 } 3209 return genericError 3210 3211 } 3212} 3213 3214type awsAwsjson11_deserializeOpUntagResource struct { 3215} 3216 3217func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 3218 return "OperationDeserializer" 3219} 3220 3221func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3222 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3223) { 3224 out, metadata, err = next.HandleDeserialize(ctx, in) 3225 if err != nil { 3226 return out, metadata, err 3227 } 3228 3229 response, ok := out.RawResponse.(*smithyhttp.Response) 3230 if !ok { 3231 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3232 } 3233 3234 if response.StatusCode < 200 || response.StatusCode >= 300 { 3235 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 3236 } 3237 output := &UntagResourceOutput{} 3238 out.Result = output 3239 3240 var buff [1024]byte 3241 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3242 3243 body := io.TeeReader(response.Body, ringBuffer) 3244 decoder := json.NewDecoder(body) 3245 decoder.UseNumber() 3246 var shape interface{} 3247 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3248 var snapshot bytes.Buffer 3249 io.Copy(&snapshot, ringBuffer) 3250 err = &smithy.DeserializationError{ 3251 Err: fmt.Errorf("failed to decode response body, %w", err), 3252 Snapshot: snapshot.Bytes(), 3253 } 3254 return out, metadata, err 3255 } 3256 3257 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 3258 if err != nil { 3259 var snapshot bytes.Buffer 3260 io.Copy(&snapshot, ringBuffer) 3261 err = &smithy.DeserializationError{ 3262 Err: fmt.Errorf("failed to decode response body, %w", err), 3263 Snapshot: snapshot.Bytes(), 3264 } 3265 return out, metadata, err 3266 } 3267 3268 return out, metadata, err 3269} 3270 3271func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3272 var errorBuffer bytes.Buffer 3273 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3274 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3275 } 3276 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3277 3278 errorCode := "UnknownError" 3279 errorMessage := errorCode 3280 3281 code := response.Header.Get("X-Amzn-ErrorType") 3282 if len(code) != 0 { 3283 errorCode = restjson.SanitizeErrorCode(code) 3284 } 3285 3286 var buff [1024]byte 3287 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3288 3289 body := io.TeeReader(errorBody, ringBuffer) 3290 decoder := json.NewDecoder(body) 3291 decoder.UseNumber() 3292 code, message, err := restjson.GetErrorInfo(decoder) 3293 if err != nil { 3294 var snapshot bytes.Buffer 3295 io.Copy(&snapshot, ringBuffer) 3296 err = &smithy.DeserializationError{ 3297 Err: fmt.Errorf("failed to decode response body, %w", err), 3298 Snapshot: snapshot.Bytes(), 3299 } 3300 return err 3301 } 3302 3303 errorBody.Seek(0, io.SeekStart) 3304 if len(code) != 0 { 3305 errorCode = restjson.SanitizeErrorCode(code) 3306 } 3307 if len(message) != 0 { 3308 errorMessage = message 3309 } 3310 3311 switch { 3312 case strings.EqualFold("InternalException", errorCode): 3313 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3314 3315 case strings.EqualFold("InvalidRequestException", errorCode): 3316 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3317 3318 default: 3319 genericError := &smithy.GenericAPIError{ 3320 Code: errorCode, 3321 Message: errorMessage, 3322 } 3323 return genericError 3324 3325 } 3326} 3327 3328type awsAwsjson11_deserializeOpUpdateAgent struct { 3329} 3330 3331func (*awsAwsjson11_deserializeOpUpdateAgent) ID() string { 3332 return "OperationDeserializer" 3333} 3334 3335func (m *awsAwsjson11_deserializeOpUpdateAgent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3336 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3337) { 3338 out, metadata, err = next.HandleDeserialize(ctx, in) 3339 if err != nil { 3340 return out, metadata, err 3341 } 3342 3343 response, ok := out.RawResponse.(*smithyhttp.Response) 3344 if !ok { 3345 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3346 } 3347 3348 if response.StatusCode < 200 || response.StatusCode >= 300 { 3349 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateAgent(response, &metadata) 3350 } 3351 output := &UpdateAgentOutput{} 3352 out.Result = output 3353 3354 var buff [1024]byte 3355 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3356 3357 body := io.TeeReader(response.Body, ringBuffer) 3358 decoder := json.NewDecoder(body) 3359 decoder.UseNumber() 3360 var shape interface{} 3361 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3362 var snapshot bytes.Buffer 3363 io.Copy(&snapshot, ringBuffer) 3364 err = &smithy.DeserializationError{ 3365 Err: fmt.Errorf("failed to decode response body, %w", err), 3366 Snapshot: snapshot.Bytes(), 3367 } 3368 return out, metadata, err 3369 } 3370 3371 err = awsAwsjson11_deserializeOpDocumentUpdateAgentOutput(&output, shape) 3372 if err != nil { 3373 var snapshot bytes.Buffer 3374 io.Copy(&snapshot, ringBuffer) 3375 err = &smithy.DeserializationError{ 3376 Err: fmt.Errorf("failed to decode response body, %w", err), 3377 Snapshot: snapshot.Bytes(), 3378 } 3379 return out, metadata, err 3380 } 3381 3382 return out, metadata, err 3383} 3384 3385func awsAwsjson11_deserializeOpErrorUpdateAgent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3386 var errorBuffer bytes.Buffer 3387 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3388 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3389 } 3390 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3391 3392 errorCode := "UnknownError" 3393 errorMessage := errorCode 3394 3395 code := response.Header.Get("X-Amzn-ErrorType") 3396 if len(code) != 0 { 3397 errorCode = restjson.SanitizeErrorCode(code) 3398 } 3399 3400 var buff [1024]byte 3401 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3402 3403 body := io.TeeReader(errorBody, ringBuffer) 3404 decoder := json.NewDecoder(body) 3405 decoder.UseNumber() 3406 code, message, err := restjson.GetErrorInfo(decoder) 3407 if err != nil { 3408 var snapshot bytes.Buffer 3409 io.Copy(&snapshot, ringBuffer) 3410 err = &smithy.DeserializationError{ 3411 Err: fmt.Errorf("failed to decode response body, %w", err), 3412 Snapshot: snapshot.Bytes(), 3413 } 3414 return err 3415 } 3416 3417 errorBody.Seek(0, io.SeekStart) 3418 if len(code) != 0 { 3419 errorCode = restjson.SanitizeErrorCode(code) 3420 } 3421 if len(message) != 0 { 3422 errorMessage = message 3423 } 3424 3425 switch { 3426 case strings.EqualFold("InternalException", errorCode): 3427 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3428 3429 case strings.EqualFold("InvalidRequestException", errorCode): 3430 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3431 3432 default: 3433 genericError := &smithy.GenericAPIError{ 3434 Code: errorCode, 3435 Message: errorMessage, 3436 } 3437 return genericError 3438 3439 } 3440} 3441 3442type awsAwsjson11_deserializeOpUpdateLocationNfs struct { 3443} 3444 3445func (*awsAwsjson11_deserializeOpUpdateLocationNfs) ID() string { 3446 return "OperationDeserializer" 3447} 3448 3449func (m *awsAwsjson11_deserializeOpUpdateLocationNfs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3450 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3451) { 3452 out, metadata, err = next.HandleDeserialize(ctx, in) 3453 if err != nil { 3454 return out, metadata, err 3455 } 3456 3457 response, ok := out.RawResponse.(*smithyhttp.Response) 3458 if !ok { 3459 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3460 } 3461 3462 if response.StatusCode < 200 || response.StatusCode >= 300 { 3463 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLocationNfs(response, &metadata) 3464 } 3465 output := &UpdateLocationNfsOutput{} 3466 out.Result = output 3467 3468 var buff [1024]byte 3469 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3470 3471 body := io.TeeReader(response.Body, ringBuffer) 3472 decoder := json.NewDecoder(body) 3473 decoder.UseNumber() 3474 var shape interface{} 3475 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3476 var snapshot bytes.Buffer 3477 io.Copy(&snapshot, ringBuffer) 3478 err = &smithy.DeserializationError{ 3479 Err: fmt.Errorf("failed to decode response body, %w", err), 3480 Snapshot: snapshot.Bytes(), 3481 } 3482 return out, metadata, err 3483 } 3484 3485 err = awsAwsjson11_deserializeOpDocumentUpdateLocationNfsOutput(&output, shape) 3486 if err != nil { 3487 var snapshot bytes.Buffer 3488 io.Copy(&snapshot, ringBuffer) 3489 err = &smithy.DeserializationError{ 3490 Err: fmt.Errorf("failed to decode response body, %w", err), 3491 Snapshot: snapshot.Bytes(), 3492 } 3493 return out, metadata, err 3494 } 3495 3496 return out, metadata, err 3497} 3498 3499func awsAwsjson11_deserializeOpErrorUpdateLocationNfs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3500 var errorBuffer bytes.Buffer 3501 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3502 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3503 } 3504 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3505 3506 errorCode := "UnknownError" 3507 errorMessage := errorCode 3508 3509 code := response.Header.Get("X-Amzn-ErrorType") 3510 if len(code) != 0 { 3511 errorCode = restjson.SanitizeErrorCode(code) 3512 } 3513 3514 var buff [1024]byte 3515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3516 3517 body := io.TeeReader(errorBody, ringBuffer) 3518 decoder := json.NewDecoder(body) 3519 decoder.UseNumber() 3520 code, message, err := restjson.GetErrorInfo(decoder) 3521 if err != nil { 3522 var snapshot bytes.Buffer 3523 io.Copy(&snapshot, ringBuffer) 3524 err = &smithy.DeserializationError{ 3525 Err: fmt.Errorf("failed to decode response body, %w", err), 3526 Snapshot: snapshot.Bytes(), 3527 } 3528 return err 3529 } 3530 3531 errorBody.Seek(0, io.SeekStart) 3532 if len(code) != 0 { 3533 errorCode = restjson.SanitizeErrorCode(code) 3534 } 3535 if len(message) != 0 { 3536 errorMessage = message 3537 } 3538 3539 switch { 3540 case strings.EqualFold("InternalException", errorCode): 3541 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3542 3543 case strings.EqualFold("InvalidRequestException", errorCode): 3544 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3545 3546 default: 3547 genericError := &smithy.GenericAPIError{ 3548 Code: errorCode, 3549 Message: errorMessage, 3550 } 3551 return genericError 3552 3553 } 3554} 3555 3556type awsAwsjson11_deserializeOpUpdateLocationObjectStorage struct { 3557} 3558 3559func (*awsAwsjson11_deserializeOpUpdateLocationObjectStorage) ID() string { 3560 return "OperationDeserializer" 3561} 3562 3563func (m *awsAwsjson11_deserializeOpUpdateLocationObjectStorage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3564 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3565) { 3566 out, metadata, err = next.HandleDeserialize(ctx, in) 3567 if err != nil { 3568 return out, metadata, err 3569 } 3570 3571 response, ok := out.RawResponse.(*smithyhttp.Response) 3572 if !ok { 3573 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3574 } 3575 3576 if response.StatusCode < 200 || response.StatusCode >= 300 { 3577 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLocationObjectStorage(response, &metadata) 3578 } 3579 output := &UpdateLocationObjectStorageOutput{} 3580 out.Result = output 3581 3582 var buff [1024]byte 3583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3584 3585 body := io.TeeReader(response.Body, ringBuffer) 3586 decoder := json.NewDecoder(body) 3587 decoder.UseNumber() 3588 var shape interface{} 3589 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3590 var snapshot bytes.Buffer 3591 io.Copy(&snapshot, ringBuffer) 3592 err = &smithy.DeserializationError{ 3593 Err: fmt.Errorf("failed to decode response body, %w", err), 3594 Snapshot: snapshot.Bytes(), 3595 } 3596 return out, metadata, err 3597 } 3598 3599 err = awsAwsjson11_deserializeOpDocumentUpdateLocationObjectStorageOutput(&output, shape) 3600 if err != nil { 3601 var snapshot bytes.Buffer 3602 io.Copy(&snapshot, ringBuffer) 3603 err = &smithy.DeserializationError{ 3604 Err: fmt.Errorf("failed to decode response body, %w", err), 3605 Snapshot: snapshot.Bytes(), 3606 } 3607 return out, metadata, err 3608 } 3609 3610 return out, metadata, err 3611} 3612 3613func awsAwsjson11_deserializeOpErrorUpdateLocationObjectStorage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3614 var errorBuffer bytes.Buffer 3615 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3616 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3617 } 3618 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3619 3620 errorCode := "UnknownError" 3621 errorMessage := errorCode 3622 3623 code := response.Header.Get("X-Amzn-ErrorType") 3624 if len(code) != 0 { 3625 errorCode = restjson.SanitizeErrorCode(code) 3626 } 3627 3628 var buff [1024]byte 3629 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3630 3631 body := io.TeeReader(errorBody, ringBuffer) 3632 decoder := json.NewDecoder(body) 3633 decoder.UseNumber() 3634 code, message, err := restjson.GetErrorInfo(decoder) 3635 if err != nil { 3636 var snapshot bytes.Buffer 3637 io.Copy(&snapshot, ringBuffer) 3638 err = &smithy.DeserializationError{ 3639 Err: fmt.Errorf("failed to decode response body, %w", err), 3640 Snapshot: snapshot.Bytes(), 3641 } 3642 return err 3643 } 3644 3645 errorBody.Seek(0, io.SeekStart) 3646 if len(code) != 0 { 3647 errorCode = restjson.SanitizeErrorCode(code) 3648 } 3649 if len(message) != 0 { 3650 errorMessage = message 3651 } 3652 3653 switch { 3654 case strings.EqualFold("InternalException", errorCode): 3655 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3656 3657 case strings.EqualFold("InvalidRequestException", errorCode): 3658 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3659 3660 default: 3661 genericError := &smithy.GenericAPIError{ 3662 Code: errorCode, 3663 Message: errorMessage, 3664 } 3665 return genericError 3666 3667 } 3668} 3669 3670type awsAwsjson11_deserializeOpUpdateLocationSmb struct { 3671} 3672 3673func (*awsAwsjson11_deserializeOpUpdateLocationSmb) ID() string { 3674 return "OperationDeserializer" 3675} 3676 3677func (m *awsAwsjson11_deserializeOpUpdateLocationSmb) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3678 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3679) { 3680 out, metadata, err = next.HandleDeserialize(ctx, in) 3681 if err != nil { 3682 return out, metadata, err 3683 } 3684 3685 response, ok := out.RawResponse.(*smithyhttp.Response) 3686 if !ok { 3687 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3688 } 3689 3690 if response.StatusCode < 200 || response.StatusCode >= 300 { 3691 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLocationSmb(response, &metadata) 3692 } 3693 output := &UpdateLocationSmbOutput{} 3694 out.Result = output 3695 3696 var buff [1024]byte 3697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3698 3699 body := io.TeeReader(response.Body, ringBuffer) 3700 decoder := json.NewDecoder(body) 3701 decoder.UseNumber() 3702 var shape interface{} 3703 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3704 var snapshot bytes.Buffer 3705 io.Copy(&snapshot, ringBuffer) 3706 err = &smithy.DeserializationError{ 3707 Err: fmt.Errorf("failed to decode response body, %w", err), 3708 Snapshot: snapshot.Bytes(), 3709 } 3710 return out, metadata, err 3711 } 3712 3713 err = awsAwsjson11_deserializeOpDocumentUpdateLocationSmbOutput(&output, shape) 3714 if err != nil { 3715 var snapshot bytes.Buffer 3716 io.Copy(&snapshot, ringBuffer) 3717 err = &smithy.DeserializationError{ 3718 Err: fmt.Errorf("failed to decode response body, %w", err), 3719 Snapshot: snapshot.Bytes(), 3720 } 3721 return out, metadata, err 3722 } 3723 3724 return out, metadata, err 3725} 3726 3727func awsAwsjson11_deserializeOpErrorUpdateLocationSmb(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3728 var errorBuffer bytes.Buffer 3729 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3730 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3731 } 3732 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3733 3734 errorCode := "UnknownError" 3735 errorMessage := errorCode 3736 3737 code := response.Header.Get("X-Amzn-ErrorType") 3738 if len(code) != 0 { 3739 errorCode = restjson.SanitizeErrorCode(code) 3740 } 3741 3742 var buff [1024]byte 3743 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3744 3745 body := io.TeeReader(errorBody, ringBuffer) 3746 decoder := json.NewDecoder(body) 3747 decoder.UseNumber() 3748 code, message, err := restjson.GetErrorInfo(decoder) 3749 if err != nil { 3750 var snapshot bytes.Buffer 3751 io.Copy(&snapshot, ringBuffer) 3752 err = &smithy.DeserializationError{ 3753 Err: fmt.Errorf("failed to decode response body, %w", err), 3754 Snapshot: snapshot.Bytes(), 3755 } 3756 return err 3757 } 3758 3759 errorBody.Seek(0, io.SeekStart) 3760 if len(code) != 0 { 3761 errorCode = restjson.SanitizeErrorCode(code) 3762 } 3763 if len(message) != 0 { 3764 errorMessage = message 3765 } 3766 3767 switch { 3768 case strings.EqualFold("InternalException", errorCode): 3769 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3770 3771 case strings.EqualFold("InvalidRequestException", errorCode): 3772 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3773 3774 default: 3775 genericError := &smithy.GenericAPIError{ 3776 Code: errorCode, 3777 Message: errorMessage, 3778 } 3779 return genericError 3780 3781 } 3782} 3783 3784type awsAwsjson11_deserializeOpUpdateTask struct { 3785} 3786 3787func (*awsAwsjson11_deserializeOpUpdateTask) ID() string { 3788 return "OperationDeserializer" 3789} 3790 3791func (m *awsAwsjson11_deserializeOpUpdateTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3792 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3793) { 3794 out, metadata, err = next.HandleDeserialize(ctx, in) 3795 if err != nil { 3796 return out, metadata, err 3797 } 3798 3799 response, ok := out.RawResponse.(*smithyhttp.Response) 3800 if !ok { 3801 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3802 } 3803 3804 if response.StatusCode < 200 || response.StatusCode >= 300 { 3805 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateTask(response, &metadata) 3806 } 3807 output := &UpdateTaskOutput{} 3808 out.Result = output 3809 3810 var buff [1024]byte 3811 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3812 3813 body := io.TeeReader(response.Body, ringBuffer) 3814 decoder := json.NewDecoder(body) 3815 decoder.UseNumber() 3816 var shape interface{} 3817 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3818 var snapshot bytes.Buffer 3819 io.Copy(&snapshot, ringBuffer) 3820 err = &smithy.DeserializationError{ 3821 Err: fmt.Errorf("failed to decode response body, %w", err), 3822 Snapshot: snapshot.Bytes(), 3823 } 3824 return out, metadata, err 3825 } 3826 3827 err = awsAwsjson11_deserializeOpDocumentUpdateTaskOutput(&output, shape) 3828 if err != nil { 3829 var snapshot bytes.Buffer 3830 io.Copy(&snapshot, ringBuffer) 3831 err = &smithy.DeserializationError{ 3832 Err: fmt.Errorf("failed to decode response body, %w", err), 3833 Snapshot: snapshot.Bytes(), 3834 } 3835 return out, metadata, err 3836 } 3837 3838 return out, metadata, err 3839} 3840 3841func awsAwsjson11_deserializeOpErrorUpdateTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3842 var errorBuffer bytes.Buffer 3843 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3844 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3845 } 3846 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3847 3848 errorCode := "UnknownError" 3849 errorMessage := errorCode 3850 3851 code := response.Header.Get("X-Amzn-ErrorType") 3852 if len(code) != 0 { 3853 errorCode = restjson.SanitizeErrorCode(code) 3854 } 3855 3856 var buff [1024]byte 3857 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3858 3859 body := io.TeeReader(errorBody, ringBuffer) 3860 decoder := json.NewDecoder(body) 3861 decoder.UseNumber() 3862 code, message, err := restjson.GetErrorInfo(decoder) 3863 if err != nil { 3864 var snapshot bytes.Buffer 3865 io.Copy(&snapshot, ringBuffer) 3866 err = &smithy.DeserializationError{ 3867 Err: fmt.Errorf("failed to decode response body, %w", err), 3868 Snapshot: snapshot.Bytes(), 3869 } 3870 return err 3871 } 3872 3873 errorBody.Seek(0, io.SeekStart) 3874 if len(code) != 0 { 3875 errorCode = restjson.SanitizeErrorCode(code) 3876 } 3877 if len(message) != 0 { 3878 errorMessage = message 3879 } 3880 3881 switch { 3882 case strings.EqualFold("InternalException", errorCode): 3883 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3884 3885 case strings.EqualFold("InvalidRequestException", errorCode): 3886 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3887 3888 default: 3889 genericError := &smithy.GenericAPIError{ 3890 Code: errorCode, 3891 Message: errorMessage, 3892 } 3893 return genericError 3894 3895 } 3896} 3897 3898type awsAwsjson11_deserializeOpUpdateTaskExecution struct { 3899} 3900 3901func (*awsAwsjson11_deserializeOpUpdateTaskExecution) ID() string { 3902 return "OperationDeserializer" 3903} 3904 3905func (m *awsAwsjson11_deserializeOpUpdateTaskExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3906 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3907) { 3908 out, metadata, err = next.HandleDeserialize(ctx, in) 3909 if err != nil { 3910 return out, metadata, err 3911 } 3912 3913 response, ok := out.RawResponse.(*smithyhttp.Response) 3914 if !ok { 3915 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3916 } 3917 3918 if response.StatusCode < 200 || response.StatusCode >= 300 { 3919 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateTaskExecution(response, &metadata) 3920 } 3921 output := &UpdateTaskExecutionOutput{} 3922 out.Result = output 3923 3924 var buff [1024]byte 3925 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3926 3927 body := io.TeeReader(response.Body, ringBuffer) 3928 decoder := json.NewDecoder(body) 3929 decoder.UseNumber() 3930 var shape interface{} 3931 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3932 var snapshot bytes.Buffer 3933 io.Copy(&snapshot, ringBuffer) 3934 err = &smithy.DeserializationError{ 3935 Err: fmt.Errorf("failed to decode response body, %w", err), 3936 Snapshot: snapshot.Bytes(), 3937 } 3938 return out, metadata, err 3939 } 3940 3941 err = awsAwsjson11_deserializeOpDocumentUpdateTaskExecutionOutput(&output, shape) 3942 if err != nil { 3943 var snapshot bytes.Buffer 3944 io.Copy(&snapshot, ringBuffer) 3945 err = &smithy.DeserializationError{ 3946 Err: fmt.Errorf("failed to decode response body, %w", err), 3947 Snapshot: snapshot.Bytes(), 3948 } 3949 return out, metadata, err 3950 } 3951 3952 return out, metadata, err 3953} 3954 3955func awsAwsjson11_deserializeOpErrorUpdateTaskExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3956 var errorBuffer bytes.Buffer 3957 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3958 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3959 } 3960 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3961 3962 errorCode := "UnknownError" 3963 errorMessage := errorCode 3964 3965 code := response.Header.Get("X-Amzn-ErrorType") 3966 if len(code) != 0 { 3967 errorCode = restjson.SanitizeErrorCode(code) 3968 } 3969 3970 var buff [1024]byte 3971 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3972 3973 body := io.TeeReader(errorBody, ringBuffer) 3974 decoder := json.NewDecoder(body) 3975 decoder.UseNumber() 3976 code, message, err := restjson.GetErrorInfo(decoder) 3977 if err != nil { 3978 var snapshot bytes.Buffer 3979 io.Copy(&snapshot, ringBuffer) 3980 err = &smithy.DeserializationError{ 3981 Err: fmt.Errorf("failed to decode response body, %w", err), 3982 Snapshot: snapshot.Bytes(), 3983 } 3984 return err 3985 } 3986 3987 errorBody.Seek(0, io.SeekStart) 3988 if len(code) != 0 { 3989 errorCode = restjson.SanitizeErrorCode(code) 3990 } 3991 if len(message) != 0 { 3992 errorMessage = message 3993 } 3994 3995 switch { 3996 case strings.EqualFold("InternalException", errorCode): 3997 return awsAwsjson11_deserializeErrorInternalException(response, errorBody) 3998 3999 case strings.EqualFold("InvalidRequestException", errorCode): 4000 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 4001 4002 default: 4003 genericError := &smithy.GenericAPIError{ 4004 Code: errorCode, 4005 Message: errorMessage, 4006 } 4007 return genericError 4008 4009 } 4010} 4011 4012func awsAwsjson11_deserializeErrorInternalException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4013 var buff [1024]byte 4014 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4015 4016 body := io.TeeReader(errorBody, ringBuffer) 4017 decoder := json.NewDecoder(body) 4018 decoder.UseNumber() 4019 var shape interface{} 4020 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4021 var snapshot bytes.Buffer 4022 io.Copy(&snapshot, ringBuffer) 4023 err = &smithy.DeserializationError{ 4024 Err: fmt.Errorf("failed to decode response body, %w", err), 4025 Snapshot: snapshot.Bytes(), 4026 } 4027 return err 4028 } 4029 4030 output := &types.InternalException{} 4031 err := awsAwsjson11_deserializeDocumentInternalException(&output, shape) 4032 4033 if err != nil { 4034 var snapshot bytes.Buffer 4035 io.Copy(&snapshot, ringBuffer) 4036 err = &smithy.DeserializationError{ 4037 Err: fmt.Errorf("failed to decode response body, %w", err), 4038 Snapshot: snapshot.Bytes(), 4039 } 4040 return err 4041 } 4042 4043 errorBody.Seek(0, io.SeekStart) 4044 return output 4045} 4046 4047func awsAwsjson11_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4048 var buff [1024]byte 4049 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4050 4051 body := io.TeeReader(errorBody, ringBuffer) 4052 decoder := json.NewDecoder(body) 4053 decoder.UseNumber() 4054 var shape interface{} 4055 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4056 var snapshot bytes.Buffer 4057 io.Copy(&snapshot, ringBuffer) 4058 err = &smithy.DeserializationError{ 4059 Err: fmt.Errorf("failed to decode response body, %w", err), 4060 Snapshot: snapshot.Bytes(), 4061 } 4062 return err 4063 } 4064 4065 output := &types.InvalidRequestException{} 4066 err := awsAwsjson11_deserializeDocumentInvalidRequestException(&output, shape) 4067 4068 if err != nil { 4069 var snapshot bytes.Buffer 4070 io.Copy(&snapshot, ringBuffer) 4071 err = &smithy.DeserializationError{ 4072 Err: fmt.Errorf("failed to decode response body, %w", err), 4073 Snapshot: snapshot.Bytes(), 4074 } 4075 return err 4076 } 4077 4078 errorBody.Seek(0, io.SeekStart) 4079 return output 4080} 4081 4082func awsAwsjson11_deserializeDocumentAgentArnList(v *[]string, value interface{}) error { 4083 if v == nil { 4084 return fmt.Errorf("unexpected nil of type %T", v) 4085 } 4086 if value == nil { 4087 return nil 4088 } 4089 4090 shape, ok := value.([]interface{}) 4091 if !ok { 4092 return fmt.Errorf("unexpected JSON type %v", value) 4093 } 4094 4095 var cv []string 4096 if *v == nil { 4097 cv = []string{} 4098 } else { 4099 cv = *v 4100 } 4101 4102 for _, value := range shape { 4103 var col string 4104 if value != nil { 4105 jtv, ok := value.(string) 4106 if !ok { 4107 return fmt.Errorf("expected AgentArn to be of type string, got %T instead", value) 4108 } 4109 col = jtv 4110 } 4111 cv = append(cv, col) 4112 4113 } 4114 *v = cv 4115 return nil 4116} 4117 4118func awsAwsjson11_deserializeDocumentAgentList(v *[]types.AgentListEntry, value interface{}) error { 4119 if v == nil { 4120 return fmt.Errorf("unexpected nil of type %T", v) 4121 } 4122 if value == nil { 4123 return nil 4124 } 4125 4126 shape, ok := value.([]interface{}) 4127 if !ok { 4128 return fmt.Errorf("unexpected JSON type %v", value) 4129 } 4130 4131 var cv []types.AgentListEntry 4132 if *v == nil { 4133 cv = []types.AgentListEntry{} 4134 } else { 4135 cv = *v 4136 } 4137 4138 for _, value := range shape { 4139 var col types.AgentListEntry 4140 destAddr := &col 4141 if err := awsAwsjson11_deserializeDocumentAgentListEntry(&destAddr, value); err != nil { 4142 return err 4143 } 4144 col = *destAddr 4145 cv = append(cv, col) 4146 4147 } 4148 *v = cv 4149 return nil 4150} 4151 4152func awsAwsjson11_deserializeDocumentAgentListEntry(v **types.AgentListEntry, value interface{}) error { 4153 if v == nil { 4154 return fmt.Errorf("unexpected nil of type %T", v) 4155 } 4156 if value == nil { 4157 return nil 4158 } 4159 4160 shape, ok := value.(map[string]interface{}) 4161 if !ok { 4162 return fmt.Errorf("unexpected JSON type %v", value) 4163 } 4164 4165 var sv *types.AgentListEntry 4166 if *v == nil { 4167 sv = &types.AgentListEntry{} 4168 } else { 4169 sv = *v 4170 } 4171 4172 for key, value := range shape { 4173 switch key { 4174 case "AgentArn": 4175 if value != nil { 4176 jtv, ok := value.(string) 4177 if !ok { 4178 return fmt.Errorf("expected AgentArn to be of type string, got %T instead", value) 4179 } 4180 sv.AgentArn = ptr.String(jtv) 4181 } 4182 4183 case "Name": 4184 if value != nil { 4185 jtv, ok := value.(string) 4186 if !ok { 4187 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 4188 } 4189 sv.Name = ptr.String(jtv) 4190 } 4191 4192 case "Status": 4193 if value != nil { 4194 jtv, ok := value.(string) 4195 if !ok { 4196 return fmt.Errorf("expected AgentStatus to be of type string, got %T instead", value) 4197 } 4198 sv.Status = types.AgentStatus(jtv) 4199 } 4200 4201 default: 4202 _, _ = key, value 4203 4204 } 4205 } 4206 *v = sv 4207 return nil 4208} 4209 4210func awsAwsjson11_deserializeDocumentDestinationNetworkInterfaceArns(v *[]string, value interface{}) error { 4211 if v == nil { 4212 return fmt.Errorf("unexpected nil of type %T", v) 4213 } 4214 if value == nil { 4215 return nil 4216 } 4217 4218 shape, ok := value.([]interface{}) 4219 if !ok { 4220 return fmt.Errorf("unexpected JSON type %v", value) 4221 } 4222 4223 var cv []string 4224 if *v == nil { 4225 cv = []string{} 4226 } else { 4227 cv = *v 4228 } 4229 4230 for _, value := range shape { 4231 var col string 4232 if value != nil { 4233 jtv, ok := value.(string) 4234 if !ok { 4235 return fmt.Errorf("expected NetworkInterfaceArn to be of type string, got %T instead", value) 4236 } 4237 col = jtv 4238 } 4239 cv = append(cv, col) 4240 4241 } 4242 *v = cv 4243 return nil 4244} 4245 4246func awsAwsjson11_deserializeDocumentEc2Config(v **types.Ec2Config, value interface{}) error { 4247 if v == nil { 4248 return fmt.Errorf("unexpected nil of type %T", v) 4249 } 4250 if value == nil { 4251 return nil 4252 } 4253 4254 shape, ok := value.(map[string]interface{}) 4255 if !ok { 4256 return fmt.Errorf("unexpected JSON type %v", value) 4257 } 4258 4259 var sv *types.Ec2Config 4260 if *v == nil { 4261 sv = &types.Ec2Config{} 4262 } else { 4263 sv = *v 4264 } 4265 4266 for key, value := range shape { 4267 switch key { 4268 case "SecurityGroupArns": 4269 if err := awsAwsjson11_deserializeDocumentEc2SecurityGroupArnList(&sv.SecurityGroupArns, value); err != nil { 4270 return err 4271 } 4272 4273 case "SubnetArn": 4274 if value != nil { 4275 jtv, ok := value.(string) 4276 if !ok { 4277 return fmt.Errorf("expected Ec2SubnetArn to be of type string, got %T instead", value) 4278 } 4279 sv.SubnetArn = ptr.String(jtv) 4280 } 4281 4282 default: 4283 _, _ = key, value 4284 4285 } 4286 } 4287 *v = sv 4288 return nil 4289} 4290 4291func awsAwsjson11_deserializeDocumentEc2SecurityGroupArnList(v *[]string, 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 []string 4305 if *v == nil { 4306 cv = []string{} 4307 } else { 4308 cv = *v 4309 } 4310 4311 for _, value := range shape { 4312 var col string 4313 if value != nil { 4314 jtv, ok := value.(string) 4315 if !ok { 4316 return fmt.Errorf("expected Ec2SecurityGroupArn to be of type string, got %T instead", value) 4317 } 4318 col = jtv 4319 } 4320 cv = append(cv, col) 4321 4322 } 4323 *v = cv 4324 return nil 4325} 4326 4327func awsAwsjson11_deserializeDocumentFilterList(v *[]types.FilterRule, value interface{}) error { 4328 if v == nil { 4329 return fmt.Errorf("unexpected nil of type %T", v) 4330 } 4331 if value == nil { 4332 return nil 4333 } 4334 4335 shape, ok := value.([]interface{}) 4336 if !ok { 4337 return fmt.Errorf("unexpected JSON type %v", value) 4338 } 4339 4340 var cv []types.FilterRule 4341 if *v == nil { 4342 cv = []types.FilterRule{} 4343 } else { 4344 cv = *v 4345 } 4346 4347 for _, value := range shape { 4348 var col types.FilterRule 4349 destAddr := &col 4350 if err := awsAwsjson11_deserializeDocumentFilterRule(&destAddr, value); err != nil { 4351 return err 4352 } 4353 col = *destAddr 4354 cv = append(cv, col) 4355 4356 } 4357 *v = cv 4358 return nil 4359} 4360 4361func awsAwsjson11_deserializeDocumentFilterRule(v **types.FilterRule, value interface{}) error { 4362 if v == nil { 4363 return fmt.Errorf("unexpected nil of type %T", v) 4364 } 4365 if value == nil { 4366 return nil 4367 } 4368 4369 shape, ok := value.(map[string]interface{}) 4370 if !ok { 4371 return fmt.Errorf("unexpected JSON type %v", value) 4372 } 4373 4374 var sv *types.FilterRule 4375 if *v == nil { 4376 sv = &types.FilterRule{} 4377 } else { 4378 sv = *v 4379 } 4380 4381 for key, value := range shape { 4382 switch key { 4383 case "FilterType": 4384 if value != nil { 4385 jtv, ok := value.(string) 4386 if !ok { 4387 return fmt.Errorf("expected FilterType to be of type string, got %T instead", value) 4388 } 4389 sv.FilterType = types.FilterType(jtv) 4390 } 4391 4392 case "Value": 4393 if value != nil { 4394 jtv, ok := value.(string) 4395 if !ok { 4396 return fmt.Errorf("expected FilterValue to be of type string, got %T instead", value) 4397 } 4398 sv.Value = ptr.String(jtv) 4399 } 4400 4401 default: 4402 _, _ = key, value 4403 4404 } 4405 } 4406 *v = sv 4407 return nil 4408} 4409 4410func awsAwsjson11_deserializeDocumentInternalException(v **types.InternalException, value interface{}) error { 4411 if v == nil { 4412 return fmt.Errorf("unexpected nil of type %T", v) 4413 } 4414 if value == nil { 4415 return nil 4416 } 4417 4418 shape, ok := value.(map[string]interface{}) 4419 if !ok { 4420 return fmt.Errorf("unexpected JSON type %v", value) 4421 } 4422 4423 var sv *types.InternalException 4424 if *v == nil { 4425 sv = &types.InternalException{} 4426 } else { 4427 sv = *v 4428 } 4429 4430 for key, value := range shape { 4431 switch key { 4432 case "errorCode": 4433 if value != nil { 4434 jtv, ok := value.(string) 4435 if !ok { 4436 return fmt.Errorf("expected string to be of type string, got %T instead", value) 4437 } 4438 sv.ErrorCode_ = ptr.String(jtv) 4439 } 4440 4441 case "message": 4442 if value != nil { 4443 jtv, ok := value.(string) 4444 if !ok { 4445 return fmt.Errorf("expected string to be of type string, got %T instead", value) 4446 } 4447 sv.Message = ptr.String(jtv) 4448 } 4449 4450 default: 4451 _, _ = key, value 4452 4453 } 4454 } 4455 *v = sv 4456 return nil 4457} 4458 4459func awsAwsjson11_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error { 4460 if v == nil { 4461 return fmt.Errorf("unexpected nil of type %T", v) 4462 } 4463 if value == nil { 4464 return nil 4465 } 4466 4467 shape, ok := value.(map[string]interface{}) 4468 if !ok { 4469 return fmt.Errorf("unexpected JSON type %v", value) 4470 } 4471 4472 var sv *types.InvalidRequestException 4473 if *v == nil { 4474 sv = &types.InvalidRequestException{} 4475 } else { 4476 sv = *v 4477 } 4478 4479 for key, value := range shape { 4480 switch key { 4481 case "errorCode": 4482 if value != nil { 4483 jtv, ok := value.(string) 4484 if !ok { 4485 return fmt.Errorf("expected string to be of type string, got %T instead", value) 4486 } 4487 sv.ErrorCode_ = ptr.String(jtv) 4488 } 4489 4490 case "message": 4491 if value != nil { 4492 jtv, ok := value.(string) 4493 if !ok { 4494 return fmt.Errorf("expected string to be of type string, got %T instead", value) 4495 } 4496 sv.Message = ptr.String(jtv) 4497 } 4498 4499 default: 4500 _, _ = key, value 4501 4502 } 4503 } 4504 *v = sv 4505 return nil 4506} 4507 4508func awsAwsjson11_deserializeDocumentLocationList(v *[]types.LocationListEntry, value interface{}) error { 4509 if v == nil { 4510 return fmt.Errorf("unexpected nil of type %T", v) 4511 } 4512 if value == nil { 4513 return nil 4514 } 4515 4516 shape, ok := value.([]interface{}) 4517 if !ok { 4518 return fmt.Errorf("unexpected JSON type %v", value) 4519 } 4520 4521 var cv []types.LocationListEntry 4522 if *v == nil { 4523 cv = []types.LocationListEntry{} 4524 } else { 4525 cv = *v 4526 } 4527 4528 for _, value := range shape { 4529 var col types.LocationListEntry 4530 destAddr := &col 4531 if err := awsAwsjson11_deserializeDocumentLocationListEntry(&destAddr, value); err != nil { 4532 return err 4533 } 4534 col = *destAddr 4535 cv = append(cv, col) 4536 4537 } 4538 *v = cv 4539 return nil 4540} 4541 4542func awsAwsjson11_deserializeDocumentLocationListEntry(v **types.LocationListEntry, value interface{}) error { 4543 if v == nil { 4544 return fmt.Errorf("unexpected nil of type %T", v) 4545 } 4546 if value == nil { 4547 return nil 4548 } 4549 4550 shape, ok := value.(map[string]interface{}) 4551 if !ok { 4552 return fmt.Errorf("unexpected JSON type %v", value) 4553 } 4554 4555 var sv *types.LocationListEntry 4556 if *v == nil { 4557 sv = &types.LocationListEntry{} 4558 } else { 4559 sv = *v 4560 } 4561 4562 for key, value := range shape { 4563 switch key { 4564 case "LocationArn": 4565 if value != nil { 4566 jtv, ok := value.(string) 4567 if !ok { 4568 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 4569 } 4570 sv.LocationArn = ptr.String(jtv) 4571 } 4572 4573 case "LocationUri": 4574 if value != nil { 4575 jtv, ok := value.(string) 4576 if !ok { 4577 return fmt.Errorf("expected LocationUri to be of type string, got %T instead", value) 4578 } 4579 sv.LocationUri = ptr.String(jtv) 4580 } 4581 4582 default: 4583 _, _ = key, value 4584 4585 } 4586 } 4587 *v = sv 4588 return nil 4589} 4590 4591func awsAwsjson11_deserializeDocumentNfsMountOptions(v **types.NfsMountOptions, value interface{}) error { 4592 if v == nil { 4593 return fmt.Errorf("unexpected nil of type %T", v) 4594 } 4595 if value == nil { 4596 return nil 4597 } 4598 4599 shape, ok := value.(map[string]interface{}) 4600 if !ok { 4601 return fmt.Errorf("unexpected JSON type %v", value) 4602 } 4603 4604 var sv *types.NfsMountOptions 4605 if *v == nil { 4606 sv = &types.NfsMountOptions{} 4607 } else { 4608 sv = *v 4609 } 4610 4611 for key, value := range shape { 4612 switch key { 4613 case "Version": 4614 if value != nil { 4615 jtv, ok := value.(string) 4616 if !ok { 4617 return fmt.Errorf("expected NfsVersion to be of type string, got %T instead", value) 4618 } 4619 sv.Version = types.NfsVersion(jtv) 4620 } 4621 4622 default: 4623 _, _ = key, value 4624 4625 } 4626 } 4627 *v = sv 4628 return nil 4629} 4630 4631func awsAwsjson11_deserializeDocumentOnPremConfig(v **types.OnPremConfig, value interface{}) error { 4632 if v == nil { 4633 return fmt.Errorf("unexpected nil of type %T", v) 4634 } 4635 if value == nil { 4636 return nil 4637 } 4638 4639 shape, ok := value.(map[string]interface{}) 4640 if !ok { 4641 return fmt.Errorf("unexpected JSON type %v", value) 4642 } 4643 4644 var sv *types.OnPremConfig 4645 if *v == nil { 4646 sv = &types.OnPremConfig{} 4647 } else { 4648 sv = *v 4649 } 4650 4651 for key, value := range shape { 4652 switch key { 4653 case "AgentArns": 4654 if err := awsAwsjson11_deserializeDocumentAgentArnList(&sv.AgentArns, value); err != nil { 4655 return err 4656 } 4657 4658 default: 4659 _, _ = key, value 4660 4661 } 4662 } 4663 *v = sv 4664 return nil 4665} 4666 4667func awsAwsjson11_deserializeDocumentOptions(v **types.Options, value interface{}) error { 4668 if v == nil { 4669 return fmt.Errorf("unexpected nil of type %T", v) 4670 } 4671 if value == nil { 4672 return nil 4673 } 4674 4675 shape, ok := value.(map[string]interface{}) 4676 if !ok { 4677 return fmt.Errorf("unexpected JSON type %v", value) 4678 } 4679 4680 var sv *types.Options 4681 if *v == nil { 4682 sv = &types.Options{} 4683 } else { 4684 sv = *v 4685 } 4686 4687 for key, value := range shape { 4688 switch key { 4689 case "Atime": 4690 if value != nil { 4691 jtv, ok := value.(string) 4692 if !ok { 4693 return fmt.Errorf("expected Atime to be of type string, got %T instead", value) 4694 } 4695 sv.Atime = types.Atime(jtv) 4696 } 4697 4698 case "BytesPerSecond": 4699 if value != nil { 4700 jtv, ok := value.(json.Number) 4701 if !ok { 4702 return fmt.Errorf("expected BytesPerSecond to be json.Number, got %T instead", value) 4703 } 4704 i64, err := jtv.Int64() 4705 if err != nil { 4706 return err 4707 } 4708 sv.BytesPerSecond = ptr.Int64(i64) 4709 } 4710 4711 case "Gid": 4712 if value != nil { 4713 jtv, ok := value.(string) 4714 if !ok { 4715 return fmt.Errorf("expected Gid to be of type string, got %T instead", value) 4716 } 4717 sv.Gid = types.Gid(jtv) 4718 } 4719 4720 case "LogLevel": 4721 if value != nil { 4722 jtv, ok := value.(string) 4723 if !ok { 4724 return fmt.Errorf("expected LogLevel to be of type string, got %T instead", value) 4725 } 4726 sv.LogLevel = types.LogLevel(jtv) 4727 } 4728 4729 case "Mtime": 4730 if value != nil { 4731 jtv, ok := value.(string) 4732 if !ok { 4733 return fmt.Errorf("expected Mtime to be of type string, got %T instead", value) 4734 } 4735 sv.Mtime = types.Mtime(jtv) 4736 } 4737 4738 case "OverwriteMode": 4739 if value != nil { 4740 jtv, ok := value.(string) 4741 if !ok { 4742 return fmt.Errorf("expected OverwriteMode to be of type string, got %T instead", value) 4743 } 4744 sv.OverwriteMode = types.OverwriteMode(jtv) 4745 } 4746 4747 case "PosixPermissions": 4748 if value != nil { 4749 jtv, ok := value.(string) 4750 if !ok { 4751 return fmt.Errorf("expected PosixPermissions to be of type string, got %T instead", value) 4752 } 4753 sv.PosixPermissions = types.PosixPermissions(jtv) 4754 } 4755 4756 case "PreserveDeletedFiles": 4757 if value != nil { 4758 jtv, ok := value.(string) 4759 if !ok { 4760 return fmt.Errorf("expected PreserveDeletedFiles to be of type string, got %T instead", value) 4761 } 4762 sv.PreserveDeletedFiles = types.PreserveDeletedFiles(jtv) 4763 } 4764 4765 case "PreserveDevices": 4766 if value != nil { 4767 jtv, ok := value.(string) 4768 if !ok { 4769 return fmt.Errorf("expected PreserveDevices to be of type string, got %T instead", value) 4770 } 4771 sv.PreserveDevices = types.PreserveDevices(jtv) 4772 } 4773 4774 case "TaskQueueing": 4775 if value != nil { 4776 jtv, ok := value.(string) 4777 if !ok { 4778 return fmt.Errorf("expected TaskQueueing to be of type string, got %T instead", value) 4779 } 4780 sv.TaskQueueing = types.TaskQueueing(jtv) 4781 } 4782 4783 case "TransferMode": 4784 if value != nil { 4785 jtv, ok := value.(string) 4786 if !ok { 4787 return fmt.Errorf("expected TransferMode to be of type string, got %T instead", value) 4788 } 4789 sv.TransferMode = types.TransferMode(jtv) 4790 } 4791 4792 case "Uid": 4793 if value != nil { 4794 jtv, ok := value.(string) 4795 if !ok { 4796 return fmt.Errorf("expected Uid to be of type string, got %T instead", value) 4797 } 4798 sv.Uid = types.Uid(jtv) 4799 } 4800 4801 case "VerifyMode": 4802 if value != nil { 4803 jtv, ok := value.(string) 4804 if !ok { 4805 return fmt.Errorf("expected VerifyMode to be of type string, got %T instead", value) 4806 } 4807 sv.VerifyMode = types.VerifyMode(jtv) 4808 } 4809 4810 default: 4811 _, _ = key, value 4812 4813 } 4814 } 4815 *v = sv 4816 return nil 4817} 4818 4819func awsAwsjson11_deserializeDocumentOutputTagList(v *[]types.TagListEntry, value interface{}) error { 4820 if v == nil { 4821 return fmt.Errorf("unexpected nil of type %T", v) 4822 } 4823 if value == nil { 4824 return nil 4825 } 4826 4827 shape, ok := value.([]interface{}) 4828 if !ok { 4829 return fmt.Errorf("unexpected JSON type %v", value) 4830 } 4831 4832 var cv []types.TagListEntry 4833 if *v == nil { 4834 cv = []types.TagListEntry{} 4835 } else { 4836 cv = *v 4837 } 4838 4839 for _, value := range shape { 4840 var col types.TagListEntry 4841 destAddr := &col 4842 if err := awsAwsjson11_deserializeDocumentTagListEntry(&destAddr, value); err != nil { 4843 return err 4844 } 4845 col = *destAddr 4846 cv = append(cv, col) 4847 4848 } 4849 *v = cv 4850 return nil 4851} 4852 4853func awsAwsjson11_deserializeDocumentPLSecurityGroupArnList(v *[]string, value interface{}) error { 4854 if v == nil { 4855 return fmt.Errorf("unexpected nil of type %T", v) 4856 } 4857 if value == nil { 4858 return nil 4859 } 4860 4861 shape, ok := value.([]interface{}) 4862 if !ok { 4863 return fmt.Errorf("unexpected JSON type %v", value) 4864 } 4865 4866 var cv []string 4867 if *v == nil { 4868 cv = []string{} 4869 } else { 4870 cv = *v 4871 } 4872 4873 for _, value := range shape { 4874 var col string 4875 if value != nil { 4876 jtv, ok := value.(string) 4877 if !ok { 4878 return fmt.Errorf("expected Ec2SecurityGroupArn to be of type string, got %T instead", value) 4879 } 4880 col = jtv 4881 } 4882 cv = append(cv, col) 4883 4884 } 4885 *v = cv 4886 return nil 4887} 4888 4889func awsAwsjson11_deserializeDocumentPLSubnetArnList(v *[]string, value interface{}) error { 4890 if v == nil { 4891 return fmt.Errorf("unexpected nil of type %T", v) 4892 } 4893 if value == nil { 4894 return nil 4895 } 4896 4897 shape, ok := value.([]interface{}) 4898 if !ok { 4899 return fmt.Errorf("unexpected JSON type %v", value) 4900 } 4901 4902 var cv []string 4903 if *v == nil { 4904 cv = []string{} 4905 } else { 4906 cv = *v 4907 } 4908 4909 for _, value := range shape { 4910 var col string 4911 if value != nil { 4912 jtv, ok := value.(string) 4913 if !ok { 4914 return fmt.Errorf("expected Ec2SubnetArn to be of type string, got %T instead", value) 4915 } 4916 col = jtv 4917 } 4918 cv = append(cv, col) 4919 4920 } 4921 *v = cv 4922 return nil 4923} 4924 4925func awsAwsjson11_deserializeDocumentPrivateLinkConfig(v **types.PrivateLinkConfig, value interface{}) error { 4926 if v == nil { 4927 return fmt.Errorf("unexpected nil of type %T", v) 4928 } 4929 if value == nil { 4930 return nil 4931 } 4932 4933 shape, ok := value.(map[string]interface{}) 4934 if !ok { 4935 return fmt.Errorf("unexpected JSON type %v", value) 4936 } 4937 4938 var sv *types.PrivateLinkConfig 4939 if *v == nil { 4940 sv = &types.PrivateLinkConfig{} 4941 } else { 4942 sv = *v 4943 } 4944 4945 for key, value := range shape { 4946 switch key { 4947 case "PrivateLinkEndpoint": 4948 if value != nil { 4949 jtv, ok := value.(string) 4950 if !ok { 4951 return fmt.Errorf("expected Endpoint to be of type string, got %T instead", value) 4952 } 4953 sv.PrivateLinkEndpoint = ptr.String(jtv) 4954 } 4955 4956 case "SecurityGroupArns": 4957 if err := awsAwsjson11_deserializeDocumentPLSecurityGroupArnList(&sv.SecurityGroupArns, value); err != nil { 4958 return err 4959 } 4960 4961 case "SubnetArns": 4962 if err := awsAwsjson11_deserializeDocumentPLSubnetArnList(&sv.SubnetArns, value); err != nil { 4963 return err 4964 } 4965 4966 case "VpcEndpointId": 4967 if value != nil { 4968 jtv, ok := value.(string) 4969 if !ok { 4970 return fmt.Errorf("expected VpcEndpointId to be of type string, got %T instead", value) 4971 } 4972 sv.VpcEndpointId = ptr.String(jtv) 4973 } 4974 4975 default: 4976 _, _ = key, value 4977 4978 } 4979 } 4980 *v = sv 4981 return nil 4982} 4983 4984func awsAwsjson11_deserializeDocumentS3Config(v **types.S3Config, value interface{}) error { 4985 if v == nil { 4986 return fmt.Errorf("unexpected nil of type %T", v) 4987 } 4988 if value == nil { 4989 return nil 4990 } 4991 4992 shape, ok := value.(map[string]interface{}) 4993 if !ok { 4994 return fmt.Errorf("unexpected JSON type %v", value) 4995 } 4996 4997 var sv *types.S3Config 4998 if *v == nil { 4999 sv = &types.S3Config{} 5000 } else { 5001 sv = *v 5002 } 5003 5004 for key, value := range shape { 5005 switch key { 5006 case "BucketAccessRoleArn": 5007 if value != nil { 5008 jtv, ok := value.(string) 5009 if !ok { 5010 return fmt.Errorf("expected IamRoleArn to be of type string, got %T instead", value) 5011 } 5012 sv.BucketAccessRoleArn = ptr.String(jtv) 5013 } 5014 5015 default: 5016 _, _ = key, value 5017 5018 } 5019 } 5020 *v = sv 5021 return nil 5022} 5023 5024func awsAwsjson11_deserializeDocumentSmbMountOptions(v **types.SmbMountOptions, value interface{}) error { 5025 if v == nil { 5026 return fmt.Errorf("unexpected nil of type %T", v) 5027 } 5028 if value == nil { 5029 return nil 5030 } 5031 5032 shape, ok := value.(map[string]interface{}) 5033 if !ok { 5034 return fmt.Errorf("unexpected JSON type %v", value) 5035 } 5036 5037 var sv *types.SmbMountOptions 5038 if *v == nil { 5039 sv = &types.SmbMountOptions{} 5040 } else { 5041 sv = *v 5042 } 5043 5044 for key, value := range shape { 5045 switch key { 5046 case "Version": 5047 if value != nil { 5048 jtv, ok := value.(string) 5049 if !ok { 5050 return fmt.Errorf("expected SmbVersion to be of type string, got %T instead", value) 5051 } 5052 sv.Version = types.SmbVersion(jtv) 5053 } 5054 5055 default: 5056 _, _ = key, value 5057 5058 } 5059 } 5060 *v = sv 5061 return nil 5062} 5063 5064func awsAwsjson11_deserializeDocumentSourceNetworkInterfaceArns(v *[]string, value interface{}) error { 5065 if v == nil { 5066 return fmt.Errorf("unexpected nil of type %T", v) 5067 } 5068 if value == nil { 5069 return nil 5070 } 5071 5072 shape, ok := value.([]interface{}) 5073 if !ok { 5074 return fmt.Errorf("unexpected JSON type %v", value) 5075 } 5076 5077 var cv []string 5078 if *v == nil { 5079 cv = []string{} 5080 } else { 5081 cv = *v 5082 } 5083 5084 for _, value := range shape { 5085 var col string 5086 if value != nil { 5087 jtv, ok := value.(string) 5088 if !ok { 5089 return fmt.Errorf("expected NetworkInterfaceArn to be of type string, got %T instead", value) 5090 } 5091 col = jtv 5092 } 5093 cv = append(cv, col) 5094 5095 } 5096 *v = cv 5097 return nil 5098} 5099 5100func awsAwsjson11_deserializeDocumentTagListEntry(v **types.TagListEntry, value interface{}) error { 5101 if v == nil { 5102 return fmt.Errorf("unexpected nil of type %T", v) 5103 } 5104 if value == nil { 5105 return nil 5106 } 5107 5108 shape, ok := value.(map[string]interface{}) 5109 if !ok { 5110 return fmt.Errorf("unexpected JSON type %v", value) 5111 } 5112 5113 var sv *types.TagListEntry 5114 if *v == nil { 5115 sv = &types.TagListEntry{} 5116 } else { 5117 sv = *v 5118 } 5119 5120 for key, value := range shape { 5121 switch key { 5122 case "Key": 5123 if value != nil { 5124 jtv, ok := value.(string) 5125 if !ok { 5126 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 5127 } 5128 sv.Key = ptr.String(jtv) 5129 } 5130 5131 case "Value": 5132 if value != nil { 5133 jtv, ok := value.(string) 5134 if !ok { 5135 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 5136 } 5137 sv.Value = ptr.String(jtv) 5138 } 5139 5140 default: 5141 _, _ = key, value 5142 5143 } 5144 } 5145 *v = sv 5146 return nil 5147} 5148 5149func awsAwsjson11_deserializeDocumentTaskExecutionList(v *[]types.TaskExecutionListEntry, value interface{}) error { 5150 if v == nil { 5151 return fmt.Errorf("unexpected nil of type %T", v) 5152 } 5153 if value == nil { 5154 return nil 5155 } 5156 5157 shape, ok := value.([]interface{}) 5158 if !ok { 5159 return fmt.Errorf("unexpected JSON type %v", value) 5160 } 5161 5162 var cv []types.TaskExecutionListEntry 5163 if *v == nil { 5164 cv = []types.TaskExecutionListEntry{} 5165 } else { 5166 cv = *v 5167 } 5168 5169 for _, value := range shape { 5170 var col types.TaskExecutionListEntry 5171 destAddr := &col 5172 if err := awsAwsjson11_deserializeDocumentTaskExecutionListEntry(&destAddr, value); err != nil { 5173 return err 5174 } 5175 col = *destAddr 5176 cv = append(cv, col) 5177 5178 } 5179 *v = cv 5180 return nil 5181} 5182 5183func awsAwsjson11_deserializeDocumentTaskExecutionListEntry(v **types.TaskExecutionListEntry, value interface{}) error { 5184 if v == nil { 5185 return fmt.Errorf("unexpected nil of type %T", v) 5186 } 5187 if value == nil { 5188 return nil 5189 } 5190 5191 shape, ok := value.(map[string]interface{}) 5192 if !ok { 5193 return fmt.Errorf("unexpected JSON type %v", value) 5194 } 5195 5196 var sv *types.TaskExecutionListEntry 5197 if *v == nil { 5198 sv = &types.TaskExecutionListEntry{} 5199 } else { 5200 sv = *v 5201 } 5202 5203 for key, value := range shape { 5204 switch key { 5205 case "Status": 5206 if value != nil { 5207 jtv, ok := value.(string) 5208 if !ok { 5209 return fmt.Errorf("expected TaskExecutionStatus to be of type string, got %T instead", value) 5210 } 5211 sv.Status = types.TaskExecutionStatus(jtv) 5212 } 5213 5214 case "TaskExecutionArn": 5215 if value != nil { 5216 jtv, ok := value.(string) 5217 if !ok { 5218 return fmt.Errorf("expected TaskExecutionArn to be of type string, got %T instead", value) 5219 } 5220 sv.TaskExecutionArn = ptr.String(jtv) 5221 } 5222 5223 default: 5224 _, _ = key, value 5225 5226 } 5227 } 5228 *v = sv 5229 return nil 5230} 5231 5232func awsAwsjson11_deserializeDocumentTaskExecutionResultDetail(v **types.TaskExecutionResultDetail, value interface{}) error { 5233 if v == nil { 5234 return fmt.Errorf("unexpected nil of type %T", v) 5235 } 5236 if value == nil { 5237 return nil 5238 } 5239 5240 shape, ok := value.(map[string]interface{}) 5241 if !ok { 5242 return fmt.Errorf("unexpected JSON type %v", value) 5243 } 5244 5245 var sv *types.TaskExecutionResultDetail 5246 if *v == nil { 5247 sv = &types.TaskExecutionResultDetail{} 5248 } else { 5249 sv = *v 5250 } 5251 5252 for key, value := range shape { 5253 switch key { 5254 case "ErrorCode": 5255 if value != nil { 5256 jtv, ok := value.(string) 5257 if !ok { 5258 return fmt.Errorf("expected string to be of type string, got %T instead", value) 5259 } 5260 sv.ErrorCode = ptr.String(jtv) 5261 } 5262 5263 case "ErrorDetail": 5264 if value != nil { 5265 jtv, ok := value.(string) 5266 if !ok { 5267 return fmt.Errorf("expected string to be of type string, got %T instead", value) 5268 } 5269 sv.ErrorDetail = ptr.String(jtv) 5270 } 5271 5272 case "PrepareDuration": 5273 if value != nil { 5274 jtv, ok := value.(json.Number) 5275 if !ok { 5276 return fmt.Errorf("expected Duration to be json.Number, got %T instead", value) 5277 } 5278 i64, err := jtv.Int64() 5279 if err != nil { 5280 return err 5281 } 5282 sv.PrepareDuration = ptr.Int64(i64) 5283 } 5284 5285 case "PrepareStatus": 5286 if value != nil { 5287 jtv, ok := value.(string) 5288 if !ok { 5289 return fmt.Errorf("expected PhaseStatus to be of type string, got %T instead", value) 5290 } 5291 sv.PrepareStatus = types.PhaseStatus(jtv) 5292 } 5293 5294 case "TotalDuration": 5295 if value != nil { 5296 jtv, ok := value.(json.Number) 5297 if !ok { 5298 return fmt.Errorf("expected Duration to be json.Number, got %T instead", value) 5299 } 5300 i64, err := jtv.Int64() 5301 if err != nil { 5302 return err 5303 } 5304 sv.TotalDuration = ptr.Int64(i64) 5305 } 5306 5307 case "TransferDuration": 5308 if value != nil { 5309 jtv, ok := value.(json.Number) 5310 if !ok { 5311 return fmt.Errorf("expected Duration to be json.Number, got %T instead", value) 5312 } 5313 i64, err := jtv.Int64() 5314 if err != nil { 5315 return err 5316 } 5317 sv.TransferDuration = ptr.Int64(i64) 5318 } 5319 5320 case "TransferStatus": 5321 if value != nil { 5322 jtv, ok := value.(string) 5323 if !ok { 5324 return fmt.Errorf("expected PhaseStatus to be of type string, got %T instead", value) 5325 } 5326 sv.TransferStatus = types.PhaseStatus(jtv) 5327 } 5328 5329 case "VerifyDuration": 5330 if value != nil { 5331 jtv, ok := value.(json.Number) 5332 if !ok { 5333 return fmt.Errorf("expected Duration to be json.Number, got %T instead", value) 5334 } 5335 i64, err := jtv.Int64() 5336 if err != nil { 5337 return err 5338 } 5339 sv.VerifyDuration = ptr.Int64(i64) 5340 } 5341 5342 case "VerifyStatus": 5343 if value != nil { 5344 jtv, ok := value.(string) 5345 if !ok { 5346 return fmt.Errorf("expected PhaseStatus to be of type string, got %T instead", value) 5347 } 5348 sv.VerifyStatus = types.PhaseStatus(jtv) 5349 } 5350 5351 default: 5352 _, _ = key, value 5353 5354 } 5355 } 5356 *v = sv 5357 return nil 5358} 5359 5360func awsAwsjson11_deserializeDocumentTaskList(v *[]types.TaskListEntry, value interface{}) error { 5361 if v == nil { 5362 return fmt.Errorf("unexpected nil of type %T", v) 5363 } 5364 if value == nil { 5365 return nil 5366 } 5367 5368 shape, ok := value.([]interface{}) 5369 if !ok { 5370 return fmt.Errorf("unexpected JSON type %v", value) 5371 } 5372 5373 var cv []types.TaskListEntry 5374 if *v == nil { 5375 cv = []types.TaskListEntry{} 5376 } else { 5377 cv = *v 5378 } 5379 5380 for _, value := range shape { 5381 var col types.TaskListEntry 5382 destAddr := &col 5383 if err := awsAwsjson11_deserializeDocumentTaskListEntry(&destAddr, value); err != nil { 5384 return err 5385 } 5386 col = *destAddr 5387 cv = append(cv, col) 5388 5389 } 5390 *v = cv 5391 return nil 5392} 5393 5394func awsAwsjson11_deserializeDocumentTaskListEntry(v **types.TaskListEntry, value interface{}) error { 5395 if v == nil { 5396 return fmt.Errorf("unexpected nil of type %T", v) 5397 } 5398 if value == nil { 5399 return nil 5400 } 5401 5402 shape, ok := value.(map[string]interface{}) 5403 if !ok { 5404 return fmt.Errorf("unexpected JSON type %v", value) 5405 } 5406 5407 var sv *types.TaskListEntry 5408 if *v == nil { 5409 sv = &types.TaskListEntry{} 5410 } else { 5411 sv = *v 5412 } 5413 5414 for key, value := range shape { 5415 switch key { 5416 case "Name": 5417 if value != nil { 5418 jtv, ok := value.(string) 5419 if !ok { 5420 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 5421 } 5422 sv.Name = ptr.String(jtv) 5423 } 5424 5425 case "Status": 5426 if value != nil { 5427 jtv, ok := value.(string) 5428 if !ok { 5429 return fmt.Errorf("expected TaskStatus to be of type string, got %T instead", value) 5430 } 5431 sv.Status = types.TaskStatus(jtv) 5432 } 5433 5434 case "TaskArn": 5435 if value != nil { 5436 jtv, ok := value.(string) 5437 if !ok { 5438 return fmt.Errorf("expected TaskArn to be of type string, got %T instead", value) 5439 } 5440 sv.TaskArn = ptr.String(jtv) 5441 } 5442 5443 default: 5444 _, _ = key, value 5445 5446 } 5447 } 5448 *v = sv 5449 return nil 5450} 5451 5452func awsAwsjson11_deserializeDocumentTaskSchedule(v **types.TaskSchedule, value interface{}) error { 5453 if v == nil { 5454 return fmt.Errorf("unexpected nil of type %T", v) 5455 } 5456 if value == nil { 5457 return nil 5458 } 5459 5460 shape, ok := value.(map[string]interface{}) 5461 if !ok { 5462 return fmt.Errorf("unexpected JSON type %v", value) 5463 } 5464 5465 var sv *types.TaskSchedule 5466 if *v == nil { 5467 sv = &types.TaskSchedule{} 5468 } else { 5469 sv = *v 5470 } 5471 5472 for key, value := range shape { 5473 switch key { 5474 case "ScheduleExpression": 5475 if value != nil { 5476 jtv, ok := value.(string) 5477 if !ok { 5478 return fmt.Errorf("expected ScheduleExpressionCron to be of type string, got %T instead", value) 5479 } 5480 sv.ScheduleExpression = ptr.String(jtv) 5481 } 5482 5483 default: 5484 _, _ = key, value 5485 5486 } 5487 } 5488 *v = sv 5489 return nil 5490} 5491 5492func awsAwsjson11_deserializeOpDocumentCancelTaskExecutionOutput(v **CancelTaskExecutionOutput, value interface{}) error { 5493 if v == nil { 5494 return fmt.Errorf("unexpected nil of type %T", v) 5495 } 5496 if value == nil { 5497 return nil 5498 } 5499 5500 shape, ok := value.(map[string]interface{}) 5501 if !ok { 5502 return fmt.Errorf("unexpected JSON type %v", value) 5503 } 5504 5505 var sv *CancelTaskExecutionOutput 5506 if *v == nil { 5507 sv = &CancelTaskExecutionOutput{} 5508 } else { 5509 sv = *v 5510 } 5511 5512 for key, value := range shape { 5513 switch key { 5514 default: 5515 _, _ = key, value 5516 5517 } 5518 } 5519 *v = sv 5520 return nil 5521} 5522 5523func awsAwsjson11_deserializeOpDocumentCreateAgentOutput(v **CreateAgentOutput, value interface{}) error { 5524 if v == nil { 5525 return fmt.Errorf("unexpected nil of type %T", v) 5526 } 5527 if value == nil { 5528 return nil 5529 } 5530 5531 shape, ok := value.(map[string]interface{}) 5532 if !ok { 5533 return fmt.Errorf("unexpected JSON type %v", value) 5534 } 5535 5536 var sv *CreateAgentOutput 5537 if *v == nil { 5538 sv = &CreateAgentOutput{} 5539 } else { 5540 sv = *v 5541 } 5542 5543 for key, value := range shape { 5544 switch key { 5545 case "AgentArn": 5546 if value != nil { 5547 jtv, ok := value.(string) 5548 if !ok { 5549 return fmt.Errorf("expected AgentArn to be of type string, got %T instead", value) 5550 } 5551 sv.AgentArn = ptr.String(jtv) 5552 } 5553 5554 default: 5555 _, _ = key, value 5556 5557 } 5558 } 5559 *v = sv 5560 return nil 5561} 5562 5563func awsAwsjson11_deserializeOpDocumentCreateLocationEfsOutput(v **CreateLocationEfsOutput, value interface{}) error { 5564 if v == nil { 5565 return fmt.Errorf("unexpected nil of type %T", v) 5566 } 5567 if value == nil { 5568 return nil 5569 } 5570 5571 shape, ok := value.(map[string]interface{}) 5572 if !ok { 5573 return fmt.Errorf("unexpected JSON type %v", value) 5574 } 5575 5576 var sv *CreateLocationEfsOutput 5577 if *v == nil { 5578 sv = &CreateLocationEfsOutput{} 5579 } else { 5580 sv = *v 5581 } 5582 5583 for key, value := range shape { 5584 switch key { 5585 case "LocationArn": 5586 if value != nil { 5587 jtv, ok := value.(string) 5588 if !ok { 5589 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 5590 } 5591 sv.LocationArn = ptr.String(jtv) 5592 } 5593 5594 default: 5595 _, _ = key, value 5596 5597 } 5598 } 5599 *v = sv 5600 return nil 5601} 5602 5603func awsAwsjson11_deserializeOpDocumentCreateLocationFsxWindowsOutput(v **CreateLocationFsxWindowsOutput, value interface{}) error { 5604 if v == nil { 5605 return fmt.Errorf("unexpected nil of type %T", v) 5606 } 5607 if value == nil { 5608 return nil 5609 } 5610 5611 shape, ok := value.(map[string]interface{}) 5612 if !ok { 5613 return fmt.Errorf("unexpected JSON type %v", value) 5614 } 5615 5616 var sv *CreateLocationFsxWindowsOutput 5617 if *v == nil { 5618 sv = &CreateLocationFsxWindowsOutput{} 5619 } else { 5620 sv = *v 5621 } 5622 5623 for key, value := range shape { 5624 switch key { 5625 case "LocationArn": 5626 if value != nil { 5627 jtv, ok := value.(string) 5628 if !ok { 5629 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 5630 } 5631 sv.LocationArn = ptr.String(jtv) 5632 } 5633 5634 default: 5635 _, _ = key, value 5636 5637 } 5638 } 5639 *v = sv 5640 return nil 5641} 5642 5643func awsAwsjson11_deserializeOpDocumentCreateLocationNfsOutput(v **CreateLocationNfsOutput, value interface{}) error { 5644 if v == nil { 5645 return fmt.Errorf("unexpected nil of type %T", v) 5646 } 5647 if value == nil { 5648 return nil 5649 } 5650 5651 shape, ok := value.(map[string]interface{}) 5652 if !ok { 5653 return fmt.Errorf("unexpected JSON type %v", value) 5654 } 5655 5656 var sv *CreateLocationNfsOutput 5657 if *v == nil { 5658 sv = &CreateLocationNfsOutput{} 5659 } else { 5660 sv = *v 5661 } 5662 5663 for key, value := range shape { 5664 switch key { 5665 case "LocationArn": 5666 if value != nil { 5667 jtv, ok := value.(string) 5668 if !ok { 5669 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 5670 } 5671 sv.LocationArn = ptr.String(jtv) 5672 } 5673 5674 default: 5675 _, _ = key, value 5676 5677 } 5678 } 5679 *v = sv 5680 return nil 5681} 5682 5683func awsAwsjson11_deserializeOpDocumentCreateLocationObjectStorageOutput(v **CreateLocationObjectStorageOutput, value interface{}) error { 5684 if v == nil { 5685 return fmt.Errorf("unexpected nil of type %T", v) 5686 } 5687 if value == nil { 5688 return nil 5689 } 5690 5691 shape, ok := value.(map[string]interface{}) 5692 if !ok { 5693 return fmt.Errorf("unexpected JSON type %v", value) 5694 } 5695 5696 var sv *CreateLocationObjectStorageOutput 5697 if *v == nil { 5698 sv = &CreateLocationObjectStorageOutput{} 5699 } else { 5700 sv = *v 5701 } 5702 5703 for key, value := range shape { 5704 switch key { 5705 case "LocationArn": 5706 if value != nil { 5707 jtv, ok := value.(string) 5708 if !ok { 5709 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 5710 } 5711 sv.LocationArn = ptr.String(jtv) 5712 } 5713 5714 default: 5715 _, _ = key, value 5716 5717 } 5718 } 5719 *v = sv 5720 return nil 5721} 5722 5723func awsAwsjson11_deserializeOpDocumentCreateLocationS3Output(v **CreateLocationS3Output, value interface{}) error { 5724 if v == nil { 5725 return fmt.Errorf("unexpected nil of type %T", v) 5726 } 5727 if value == nil { 5728 return nil 5729 } 5730 5731 shape, ok := value.(map[string]interface{}) 5732 if !ok { 5733 return fmt.Errorf("unexpected JSON type %v", value) 5734 } 5735 5736 var sv *CreateLocationS3Output 5737 if *v == nil { 5738 sv = &CreateLocationS3Output{} 5739 } else { 5740 sv = *v 5741 } 5742 5743 for key, value := range shape { 5744 switch key { 5745 case "LocationArn": 5746 if value != nil { 5747 jtv, ok := value.(string) 5748 if !ok { 5749 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 5750 } 5751 sv.LocationArn = ptr.String(jtv) 5752 } 5753 5754 default: 5755 _, _ = key, value 5756 5757 } 5758 } 5759 *v = sv 5760 return nil 5761} 5762 5763func awsAwsjson11_deserializeOpDocumentCreateLocationSmbOutput(v **CreateLocationSmbOutput, value interface{}) error { 5764 if v == nil { 5765 return fmt.Errorf("unexpected nil of type %T", v) 5766 } 5767 if value == nil { 5768 return nil 5769 } 5770 5771 shape, ok := value.(map[string]interface{}) 5772 if !ok { 5773 return fmt.Errorf("unexpected JSON type %v", value) 5774 } 5775 5776 var sv *CreateLocationSmbOutput 5777 if *v == nil { 5778 sv = &CreateLocationSmbOutput{} 5779 } else { 5780 sv = *v 5781 } 5782 5783 for key, value := range shape { 5784 switch key { 5785 case "LocationArn": 5786 if value != nil { 5787 jtv, ok := value.(string) 5788 if !ok { 5789 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 5790 } 5791 sv.LocationArn = ptr.String(jtv) 5792 } 5793 5794 default: 5795 _, _ = key, value 5796 5797 } 5798 } 5799 *v = sv 5800 return nil 5801} 5802 5803func awsAwsjson11_deserializeOpDocumentCreateTaskOutput(v **CreateTaskOutput, value interface{}) error { 5804 if v == nil { 5805 return fmt.Errorf("unexpected nil of type %T", v) 5806 } 5807 if value == nil { 5808 return nil 5809 } 5810 5811 shape, ok := value.(map[string]interface{}) 5812 if !ok { 5813 return fmt.Errorf("unexpected JSON type %v", value) 5814 } 5815 5816 var sv *CreateTaskOutput 5817 if *v == nil { 5818 sv = &CreateTaskOutput{} 5819 } else { 5820 sv = *v 5821 } 5822 5823 for key, value := range shape { 5824 switch key { 5825 case "TaskArn": 5826 if value != nil { 5827 jtv, ok := value.(string) 5828 if !ok { 5829 return fmt.Errorf("expected TaskArn to be of type string, got %T instead", value) 5830 } 5831 sv.TaskArn = ptr.String(jtv) 5832 } 5833 5834 default: 5835 _, _ = key, value 5836 5837 } 5838 } 5839 *v = sv 5840 return nil 5841} 5842 5843func awsAwsjson11_deserializeOpDocumentDeleteAgentOutput(v **DeleteAgentOutput, value interface{}) error { 5844 if v == nil { 5845 return fmt.Errorf("unexpected nil of type %T", v) 5846 } 5847 if value == nil { 5848 return nil 5849 } 5850 5851 shape, ok := value.(map[string]interface{}) 5852 if !ok { 5853 return fmt.Errorf("unexpected JSON type %v", value) 5854 } 5855 5856 var sv *DeleteAgentOutput 5857 if *v == nil { 5858 sv = &DeleteAgentOutput{} 5859 } else { 5860 sv = *v 5861 } 5862 5863 for key, value := range shape { 5864 switch key { 5865 default: 5866 _, _ = key, value 5867 5868 } 5869 } 5870 *v = sv 5871 return nil 5872} 5873 5874func awsAwsjson11_deserializeOpDocumentDeleteLocationOutput(v **DeleteLocationOutput, value interface{}) error { 5875 if v == nil { 5876 return fmt.Errorf("unexpected nil of type %T", v) 5877 } 5878 if value == nil { 5879 return nil 5880 } 5881 5882 shape, ok := value.(map[string]interface{}) 5883 if !ok { 5884 return fmt.Errorf("unexpected JSON type %v", value) 5885 } 5886 5887 var sv *DeleteLocationOutput 5888 if *v == nil { 5889 sv = &DeleteLocationOutput{} 5890 } else { 5891 sv = *v 5892 } 5893 5894 for key, value := range shape { 5895 switch key { 5896 default: 5897 _, _ = key, value 5898 5899 } 5900 } 5901 *v = sv 5902 return nil 5903} 5904 5905func awsAwsjson11_deserializeOpDocumentDeleteTaskOutput(v **DeleteTaskOutput, value interface{}) error { 5906 if v == nil { 5907 return fmt.Errorf("unexpected nil of type %T", v) 5908 } 5909 if value == nil { 5910 return nil 5911 } 5912 5913 shape, ok := value.(map[string]interface{}) 5914 if !ok { 5915 return fmt.Errorf("unexpected JSON type %v", value) 5916 } 5917 5918 var sv *DeleteTaskOutput 5919 if *v == nil { 5920 sv = &DeleteTaskOutput{} 5921 } else { 5922 sv = *v 5923 } 5924 5925 for key, value := range shape { 5926 switch key { 5927 default: 5928 _, _ = key, value 5929 5930 } 5931 } 5932 *v = sv 5933 return nil 5934} 5935 5936func awsAwsjson11_deserializeOpDocumentDescribeAgentOutput(v **DescribeAgentOutput, value interface{}) error { 5937 if v == nil { 5938 return fmt.Errorf("unexpected nil of type %T", v) 5939 } 5940 if value == nil { 5941 return nil 5942 } 5943 5944 shape, ok := value.(map[string]interface{}) 5945 if !ok { 5946 return fmt.Errorf("unexpected JSON type %v", value) 5947 } 5948 5949 var sv *DescribeAgentOutput 5950 if *v == nil { 5951 sv = &DescribeAgentOutput{} 5952 } else { 5953 sv = *v 5954 } 5955 5956 for key, value := range shape { 5957 switch key { 5958 case "AgentArn": 5959 if value != nil { 5960 jtv, ok := value.(string) 5961 if !ok { 5962 return fmt.Errorf("expected AgentArn to be of type string, got %T instead", value) 5963 } 5964 sv.AgentArn = ptr.String(jtv) 5965 } 5966 5967 case "CreationTime": 5968 if value != nil { 5969 jtv, ok := value.(json.Number) 5970 if !ok { 5971 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 5972 } 5973 f64, err := jtv.Float64() 5974 if err != nil { 5975 return err 5976 } 5977 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5978 } 5979 5980 case "EndpointType": 5981 if value != nil { 5982 jtv, ok := value.(string) 5983 if !ok { 5984 return fmt.Errorf("expected EndpointType to be of type string, got %T instead", value) 5985 } 5986 sv.EndpointType = types.EndpointType(jtv) 5987 } 5988 5989 case "LastConnectionTime": 5990 if value != nil { 5991 jtv, ok := value.(json.Number) 5992 if !ok { 5993 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 5994 } 5995 f64, err := jtv.Float64() 5996 if err != nil { 5997 return err 5998 } 5999 sv.LastConnectionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6000 } 6001 6002 case "Name": 6003 if value != nil { 6004 jtv, ok := value.(string) 6005 if !ok { 6006 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 6007 } 6008 sv.Name = ptr.String(jtv) 6009 } 6010 6011 case "PrivateLinkConfig": 6012 if err := awsAwsjson11_deserializeDocumentPrivateLinkConfig(&sv.PrivateLinkConfig, value); err != nil { 6013 return err 6014 } 6015 6016 case "Status": 6017 if value != nil { 6018 jtv, ok := value.(string) 6019 if !ok { 6020 return fmt.Errorf("expected AgentStatus to be of type string, got %T instead", value) 6021 } 6022 sv.Status = types.AgentStatus(jtv) 6023 } 6024 6025 default: 6026 _, _ = key, value 6027 6028 } 6029 } 6030 *v = sv 6031 return nil 6032} 6033 6034func awsAwsjson11_deserializeOpDocumentDescribeLocationEfsOutput(v **DescribeLocationEfsOutput, value interface{}) error { 6035 if v == nil { 6036 return fmt.Errorf("unexpected nil of type %T", v) 6037 } 6038 if value == nil { 6039 return nil 6040 } 6041 6042 shape, ok := value.(map[string]interface{}) 6043 if !ok { 6044 return fmt.Errorf("unexpected JSON type %v", value) 6045 } 6046 6047 var sv *DescribeLocationEfsOutput 6048 if *v == nil { 6049 sv = &DescribeLocationEfsOutput{} 6050 } else { 6051 sv = *v 6052 } 6053 6054 for key, value := range shape { 6055 switch key { 6056 case "CreationTime": 6057 if value != nil { 6058 jtv, ok := value.(json.Number) 6059 if !ok { 6060 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6061 } 6062 f64, err := jtv.Float64() 6063 if err != nil { 6064 return err 6065 } 6066 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6067 } 6068 6069 case "Ec2Config": 6070 if err := awsAwsjson11_deserializeDocumentEc2Config(&sv.Ec2Config, value); err != nil { 6071 return err 6072 } 6073 6074 case "LocationArn": 6075 if value != nil { 6076 jtv, ok := value.(string) 6077 if !ok { 6078 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6079 } 6080 sv.LocationArn = ptr.String(jtv) 6081 } 6082 6083 case "LocationUri": 6084 if value != nil { 6085 jtv, ok := value.(string) 6086 if !ok { 6087 return fmt.Errorf("expected LocationUri to be of type string, got %T instead", value) 6088 } 6089 sv.LocationUri = ptr.String(jtv) 6090 } 6091 6092 default: 6093 _, _ = key, value 6094 6095 } 6096 } 6097 *v = sv 6098 return nil 6099} 6100 6101func awsAwsjson11_deserializeOpDocumentDescribeLocationFsxWindowsOutput(v **DescribeLocationFsxWindowsOutput, value interface{}) error { 6102 if v == nil { 6103 return fmt.Errorf("unexpected nil of type %T", v) 6104 } 6105 if value == nil { 6106 return nil 6107 } 6108 6109 shape, ok := value.(map[string]interface{}) 6110 if !ok { 6111 return fmt.Errorf("unexpected JSON type %v", value) 6112 } 6113 6114 var sv *DescribeLocationFsxWindowsOutput 6115 if *v == nil { 6116 sv = &DescribeLocationFsxWindowsOutput{} 6117 } else { 6118 sv = *v 6119 } 6120 6121 for key, value := range shape { 6122 switch key { 6123 case "CreationTime": 6124 if value != nil { 6125 jtv, ok := value.(json.Number) 6126 if !ok { 6127 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6128 } 6129 f64, err := jtv.Float64() 6130 if err != nil { 6131 return err 6132 } 6133 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6134 } 6135 6136 case "Domain": 6137 if value != nil { 6138 jtv, ok := value.(string) 6139 if !ok { 6140 return fmt.Errorf("expected SmbDomain to be of type string, got %T instead", value) 6141 } 6142 sv.Domain = ptr.String(jtv) 6143 } 6144 6145 case "LocationArn": 6146 if value != nil { 6147 jtv, ok := value.(string) 6148 if !ok { 6149 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6150 } 6151 sv.LocationArn = ptr.String(jtv) 6152 } 6153 6154 case "LocationUri": 6155 if value != nil { 6156 jtv, ok := value.(string) 6157 if !ok { 6158 return fmt.Errorf("expected LocationUri to be of type string, got %T instead", value) 6159 } 6160 sv.LocationUri = ptr.String(jtv) 6161 } 6162 6163 case "SecurityGroupArns": 6164 if err := awsAwsjson11_deserializeDocumentEc2SecurityGroupArnList(&sv.SecurityGroupArns, value); err != nil { 6165 return err 6166 } 6167 6168 case "User": 6169 if value != nil { 6170 jtv, ok := value.(string) 6171 if !ok { 6172 return fmt.Errorf("expected SmbUser to be of type string, got %T instead", value) 6173 } 6174 sv.User = ptr.String(jtv) 6175 } 6176 6177 default: 6178 _, _ = key, value 6179 6180 } 6181 } 6182 *v = sv 6183 return nil 6184} 6185 6186func awsAwsjson11_deserializeOpDocumentDescribeLocationNfsOutput(v **DescribeLocationNfsOutput, value interface{}) error { 6187 if v == nil { 6188 return fmt.Errorf("unexpected nil of type %T", v) 6189 } 6190 if value == nil { 6191 return nil 6192 } 6193 6194 shape, ok := value.(map[string]interface{}) 6195 if !ok { 6196 return fmt.Errorf("unexpected JSON type %v", value) 6197 } 6198 6199 var sv *DescribeLocationNfsOutput 6200 if *v == nil { 6201 sv = &DescribeLocationNfsOutput{} 6202 } else { 6203 sv = *v 6204 } 6205 6206 for key, value := range shape { 6207 switch key { 6208 case "CreationTime": 6209 if value != nil { 6210 jtv, ok := value.(json.Number) 6211 if !ok { 6212 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6213 } 6214 f64, err := jtv.Float64() 6215 if err != nil { 6216 return err 6217 } 6218 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6219 } 6220 6221 case "LocationArn": 6222 if value != nil { 6223 jtv, ok := value.(string) 6224 if !ok { 6225 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6226 } 6227 sv.LocationArn = ptr.String(jtv) 6228 } 6229 6230 case "LocationUri": 6231 if value != nil { 6232 jtv, ok := value.(string) 6233 if !ok { 6234 return fmt.Errorf("expected LocationUri to be of type string, got %T instead", value) 6235 } 6236 sv.LocationUri = ptr.String(jtv) 6237 } 6238 6239 case "MountOptions": 6240 if err := awsAwsjson11_deserializeDocumentNfsMountOptions(&sv.MountOptions, value); err != nil { 6241 return err 6242 } 6243 6244 case "OnPremConfig": 6245 if err := awsAwsjson11_deserializeDocumentOnPremConfig(&sv.OnPremConfig, value); err != nil { 6246 return err 6247 } 6248 6249 default: 6250 _, _ = key, value 6251 6252 } 6253 } 6254 *v = sv 6255 return nil 6256} 6257 6258func awsAwsjson11_deserializeOpDocumentDescribeLocationObjectStorageOutput(v **DescribeLocationObjectStorageOutput, value interface{}) error { 6259 if v == nil { 6260 return fmt.Errorf("unexpected nil of type %T", v) 6261 } 6262 if value == nil { 6263 return nil 6264 } 6265 6266 shape, ok := value.(map[string]interface{}) 6267 if !ok { 6268 return fmt.Errorf("unexpected JSON type %v", value) 6269 } 6270 6271 var sv *DescribeLocationObjectStorageOutput 6272 if *v == nil { 6273 sv = &DescribeLocationObjectStorageOutput{} 6274 } else { 6275 sv = *v 6276 } 6277 6278 for key, value := range shape { 6279 switch key { 6280 case "AccessKey": 6281 if value != nil { 6282 jtv, ok := value.(string) 6283 if !ok { 6284 return fmt.Errorf("expected ObjectStorageAccessKey to be of type string, got %T instead", value) 6285 } 6286 sv.AccessKey = ptr.String(jtv) 6287 } 6288 6289 case "AgentArns": 6290 if err := awsAwsjson11_deserializeDocumentAgentArnList(&sv.AgentArns, value); err != nil { 6291 return err 6292 } 6293 6294 case "CreationTime": 6295 if value != nil { 6296 jtv, ok := value.(json.Number) 6297 if !ok { 6298 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6299 } 6300 f64, err := jtv.Float64() 6301 if err != nil { 6302 return err 6303 } 6304 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6305 } 6306 6307 case "LocationArn": 6308 if value != nil { 6309 jtv, ok := value.(string) 6310 if !ok { 6311 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6312 } 6313 sv.LocationArn = ptr.String(jtv) 6314 } 6315 6316 case "LocationUri": 6317 if value != nil { 6318 jtv, ok := value.(string) 6319 if !ok { 6320 return fmt.Errorf("expected LocationUri to be of type string, got %T instead", value) 6321 } 6322 sv.LocationUri = ptr.String(jtv) 6323 } 6324 6325 case "ServerPort": 6326 if value != nil { 6327 jtv, ok := value.(json.Number) 6328 if !ok { 6329 return fmt.Errorf("expected ObjectStorageServerPort to be json.Number, got %T instead", value) 6330 } 6331 i64, err := jtv.Int64() 6332 if err != nil { 6333 return err 6334 } 6335 sv.ServerPort = ptr.Int32(int32(i64)) 6336 } 6337 6338 case "ServerProtocol": 6339 if value != nil { 6340 jtv, ok := value.(string) 6341 if !ok { 6342 return fmt.Errorf("expected ObjectStorageServerProtocol to be of type string, got %T instead", value) 6343 } 6344 sv.ServerProtocol = types.ObjectStorageServerProtocol(jtv) 6345 } 6346 6347 default: 6348 _, _ = key, value 6349 6350 } 6351 } 6352 *v = sv 6353 return nil 6354} 6355 6356func awsAwsjson11_deserializeOpDocumentDescribeLocationS3Output(v **DescribeLocationS3Output, value interface{}) error { 6357 if v == nil { 6358 return fmt.Errorf("unexpected nil of type %T", v) 6359 } 6360 if value == nil { 6361 return nil 6362 } 6363 6364 shape, ok := value.(map[string]interface{}) 6365 if !ok { 6366 return fmt.Errorf("unexpected JSON type %v", value) 6367 } 6368 6369 var sv *DescribeLocationS3Output 6370 if *v == nil { 6371 sv = &DescribeLocationS3Output{} 6372 } else { 6373 sv = *v 6374 } 6375 6376 for key, value := range shape { 6377 switch key { 6378 case "AgentArns": 6379 if err := awsAwsjson11_deserializeDocumentAgentArnList(&sv.AgentArns, value); err != nil { 6380 return err 6381 } 6382 6383 case "CreationTime": 6384 if value != nil { 6385 jtv, ok := value.(json.Number) 6386 if !ok { 6387 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6388 } 6389 f64, err := jtv.Float64() 6390 if err != nil { 6391 return err 6392 } 6393 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6394 } 6395 6396 case "LocationArn": 6397 if value != nil { 6398 jtv, ok := value.(string) 6399 if !ok { 6400 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6401 } 6402 sv.LocationArn = ptr.String(jtv) 6403 } 6404 6405 case "LocationUri": 6406 if value != nil { 6407 jtv, ok := value.(string) 6408 if !ok { 6409 return fmt.Errorf("expected LocationUri to be of type string, got %T instead", value) 6410 } 6411 sv.LocationUri = ptr.String(jtv) 6412 } 6413 6414 case "S3Config": 6415 if err := awsAwsjson11_deserializeDocumentS3Config(&sv.S3Config, value); err != nil { 6416 return err 6417 } 6418 6419 case "S3StorageClass": 6420 if value != nil { 6421 jtv, ok := value.(string) 6422 if !ok { 6423 return fmt.Errorf("expected S3StorageClass to be of type string, got %T instead", value) 6424 } 6425 sv.S3StorageClass = types.S3StorageClass(jtv) 6426 } 6427 6428 default: 6429 _, _ = key, value 6430 6431 } 6432 } 6433 *v = sv 6434 return nil 6435} 6436 6437func awsAwsjson11_deserializeOpDocumentDescribeLocationSmbOutput(v **DescribeLocationSmbOutput, value interface{}) error { 6438 if v == nil { 6439 return fmt.Errorf("unexpected nil of type %T", v) 6440 } 6441 if value == nil { 6442 return nil 6443 } 6444 6445 shape, ok := value.(map[string]interface{}) 6446 if !ok { 6447 return fmt.Errorf("unexpected JSON type %v", value) 6448 } 6449 6450 var sv *DescribeLocationSmbOutput 6451 if *v == nil { 6452 sv = &DescribeLocationSmbOutput{} 6453 } else { 6454 sv = *v 6455 } 6456 6457 for key, value := range shape { 6458 switch key { 6459 case "AgentArns": 6460 if err := awsAwsjson11_deserializeDocumentAgentArnList(&sv.AgentArns, value); err != nil { 6461 return err 6462 } 6463 6464 case "CreationTime": 6465 if value != nil { 6466 jtv, ok := value.(json.Number) 6467 if !ok { 6468 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6469 } 6470 f64, err := jtv.Float64() 6471 if err != nil { 6472 return err 6473 } 6474 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6475 } 6476 6477 case "Domain": 6478 if value != nil { 6479 jtv, ok := value.(string) 6480 if !ok { 6481 return fmt.Errorf("expected SmbDomain to be of type string, got %T instead", value) 6482 } 6483 sv.Domain = ptr.String(jtv) 6484 } 6485 6486 case "LocationArn": 6487 if value != nil { 6488 jtv, ok := value.(string) 6489 if !ok { 6490 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6491 } 6492 sv.LocationArn = ptr.String(jtv) 6493 } 6494 6495 case "LocationUri": 6496 if value != nil { 6497 jtv, ok := value.(string) 6498 if !ok { 6499 return fmt.Errorf("expected LocationUri to be of type string, got %T instead", value) 6500 } 6501 sv.LocationUri = ptr.String(jtv) 6502 } 6503 6504 case "MountOptions": 6505 if err := awsAwsjson11_deserializeDocumentSmbMountOptions(&sv.MountOptions, value); err != nil { 6506 return err 6507 } 6508 6509 case "User": 6510 if value != nil { 6511 jtv, ok := value.(string) 6512 if !ok { 6513 return fmt.Errorf("expected SmbUser to be of type string, got %T instead", value) 6514 } 6515 sv.User = ptr.String(jtv) 6516 } 6517 6518 default: 6519 _, _ = key, value 6520 6521 } 6522 } 6523 *v = sv 6524 return nil 6525} 6526 6527func awsAwsjson11_deserializeOpDocumentDescribeTaskExecutionOutput(v **DescribeTaskExecutionOutput, value interface{}) error { 6528 if v == nil { 6529 return fmt.Errorf("unexpected nil of type %T", v) 6530 } 6531 if value == nil { 6532 return nil 6533 } 6534 6535 shape, ok := value.(map[string]interface{}) 6536 if !ok { 6537 return fmt.Errorf("unexpected JSON type %v", value) 6538 } 6539 6540 var sv *DescribeTaskExecutionOutput 6541 if *v == nil { 6542 sv = &DescribeTaskExecutionOutput{} 6543 } else { 6544 sv = *v 6545 } 6546 6547 for key, value := range shape { 6548 switch key { 6549 case "BytesTransferred": 6550 if value != nil { 6551 jtv, ok := value.(json.Number) 6552 if !ok { 6553 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 6554 } 6555 i64, err := jtv.Int64() 6556 if err != nil { 6557 return err 6558 } 6559 sv.BytesTransferred = i64 6560 } 6561 6562 case "BytesWritten": 6563 if value != nil { 6564 jtv, ok := value.(json.Number) 6565 if !ok { 6566 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 6567 } 6568 i64, err := jtv.Int64() 6569 if err != nil { 6570 return err 6571 } 6572 sv.BytesWritten = i64 6573 } 6574 6575 case "EstimatedBytesToTransfer": 6576 if value != nil { 6577 jtv, ok := value.(json.Number) 6578 if !ok { 6579 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 6580 } 6581 i64, err := jtv.Int64() 6582 if err != nil { 6583 return err 6584 } 6585 sv.EstimatedBytesToTransfer = i64 6586 } 6587 6588 case "EstimatedFilesToTransfer": 6589 if value != nil { 6590 jtv, ok := value.(json.Number) 6591 if !ok { 6592 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 6593 } 6594 i64, err := jtv.Int64() 6595 if err != nil { 6596 return err 6597 } 6598 sv.EstimatedFilesToTransfer = i64 6599 } 6600 6601 case "Excludes": 6602 if err := awsAwsjson11_deserializeDocumentFilterList(&sv.Excludes, value); err != nil { 6603 return err 6604 } 6605 6606 case "FilesTransferred": 6607 if value != nil { 6608 jtv, ok := value.(json.Number) 6609 if !ok { 6610 return fmt.Errorf("expected long to be json.Number, got %T instead", value) 6611 } 6612 i64, err := jtv.Int64() 6613 if err != nil { 6614 return err 6615 } 6616 sv.FilesTransferred = i64 6617 } 6618 6619 case "Includes": 6620 if err := awsAwsjson11_deserializeDocumentFilterList(&sv.Includes, value); err != nil { 6621 return err 6622 } 6623 6624 case "Options": 6625 if err := awsAwsjson11_deserializeDocumentOptions(&sv.Options, value); err != nil { 6626 return err 6627 } 6628 6629 case "Result": 6630 if err := awsAwsjson11_deserializeDocumentTaskExecutionResultDetail(&sv.Result, value); err != nil { 6631 return err 6632 } 6633 6634 case "StartTime": 6635 if value != nil { 6636 jtv, ok := value.(json.Number) 6637 if !ok { 6638 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6639 } 6640 f64, err := jtv.Float64() 6641 if err != nil { 6642 return err 6643 } 6644 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6645 } 6646 6647 case "Status": 6648 if value != nil { 6649 jtv, ok := value.(string) 6650 if !ok { 6651 return fmt.Errorf("expected TaskExecutionStatus to be of type string, got %T instead", value) 6652 } 6653 sv.Status = types.TaskExecutionStatus(jtv) 6654 } 6655 6656 case "TaskExecutionArn": 6657 if value != nil { 6658 jtv, ok := value.(string) 6659 if !ok { 6660 return fmt.Errorf("expected TaskExecutionArn to be of type string, got %T instead", value) 6661 } 6662 sv.TaskExecutionArn = ptr.String(jtv) 6663 } 6664 6665 default: 6666 _, _ = key, value 6667 6668 } 6669 } 6670 *v = sv 6671 return nil 6672} 6673 6674func awsAwsjson11_deserializeOpDocumentDescribeTaskOutput(v **DescribeTaskOutput, value interface{}) error { 6675 if v == nil { 6676 return fmt.Errorf("unexpected nil of type %T", v) 6677 } 6678 if value == nil { 6679 return nil 6680 } 6681 6682 shape, ok := value.(map[string]interface{}) 6683 if !ok { 6684 return fmt.Errorf("unexpected JSON type %v", value) 6685 } 6686 6687 var sv *DescribeTaskOutput 6688 if *v == nil { 6689 sv = &DescribeTaskOutput{} 6690 } else { 6691 sv = *v 6692 } 6693 6694 for key, value := range shape { 6695 switch key { 6696 case "CloudWatchLogGroupArn": 6697 if value != nil { 6698 jtv, ok := value.(string) 6699 if !ok { 6700 return fmt.Errorf("expected LogGroupArn to be of type string, got %T instead", value) 6701 } 6702 sv.CloudWatchLogGroupArn = ptr.String(jtv) 6703 } 6704 6705 case "CreationTime": 6706 if value != nil { 6707 jtv, ok := value.(json.Number) 6708 if !ok { 6709 return fmt.Errorf("expected Time to be json.Number, got %T instead", value) 6710 } 6711 f64, err := jtv.Float64() 6712 if err != nil { 6713 return err 6714 } 6715 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6716 } 6717 6718 case "CurrentTaskExecutionArn": 6719 if value != nil { 6720 jtv, ok := value.(string) 6721 if !ok { 6722 return fmt.Errorf("expected TaskExecutionArn to be of type string, got %T instead", value) 6723 } 6724 sv.CurrentTaskExecutionArn = ptr.String(jtv) 6725 } 6726 6727 case "DestinationLocationArn": 6728 if value != nil { 6729 jtv, ok := value.(string) 6730 if !ok { 6731 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6732 } 6733 sv.DestinationLocationArn = ptr.String(jtv) 6734 } 6735 6736 case "DestinationNetworkInterfaceArns": 6737 if err := awsAwsjson11_deserializeDocumentDestinationNetworkInterfaceArns(&sv.DestinationNetworkInterfaceArns, value); err != nil { 6738 return err 6739 } 6740 6741 case "ErrorCode": 6742 if value != nil { 6743 jtv, ok := value.(string) 6744 if !ok { 6745 return fmt.Errorf("expected string to be of type string, got %T instead", value) 6746 } 6747 sv.ErrorCode = ptr.String(jtv) 6748 } 6749 6750 case "ErrorDetail": 6751 if value != nil { 6752 jtv, ok := value.(string) 6753 if !ok { 6754 return fmt.Errorf("expected string to be of type string, got %T instead", value) 6755 } 6756 sv.ErrorDetail = ptr.String(jtv) 6757 } 6758 6759 case "Excludes": 6760 if err := awsAwsjson11_deserializeDocumentFilterList(&sv.Excludes, value); err != nil { 6761 return err 6762 } 6763 6764 case "Name": 6765 if value != nil { 6766 jtv, ok := value.(string) 6767 if !ok { 6768 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 6769 } 6770 sv.Name = ptr.String(jtv) 6771 } 6772 6773 case "Options": 6774 if err := awsAwsjson11_deserializeDocumentOptions(&sv.Options, value); err != nil { 6775 return err 6776 } 6777 6778 case "Schedule": 6779 if err := awsAwsjson11_deserializeDocumentTaskSchedule(&sv.Schedule, value); err != nil { 6780 return err 6781 } 6782 6783 case "SourceLocationArn": 6784 if value != nil { 6785 jtv, ok := value.(string) 6786 if !ok { 6787 return fmt.Errorf("expected LocationArn to be of type string, got %T instead", value) 6788 } 6789 sv.SourceLocationArn = ptr.String(jtv) 6790 } 6791 6792 case "SourceNetworkInterfaceArns": 6793 if err := awsAwsjson11_deserializeDocumentSourceNetworkInterfaceArns(&sv.SourceNetworkInterfaceArns, value); err != nil { 6794 return err 6795 } 6796 6797 case "Status": 6798 if value != nil { 6799 jtv, ok := value.(string) 6800 if !ok { 6801 return fmt.Errorf("expected TaskStatus to be of type string, got %T instead", value) 6802 } 6803 sv.Status = types.TaskStatus(jtv) 6804 } 6805 6806 case "TaskArn": 6807 if value != nil { 6808 jtv, ok := value.(string) 6809 if !ok { 6810 return fmt.Errorf("expected TaskArn to be of type string, got %T instead", value) 6811 } 6812 sv.TaskArn = ptr.String(jtv) 6813 } 6814 6815 default: 6816 _, _ = key, value 6817 6818 } 6819 } 6820 *v = sv 6821 return nil 6822} 6823 6824func awsAwsjson11_deserializeOpDocumentListAgentsOutput(v **ListAgentsOutput, value interface{}) error { 6825 if v == nil { 6826 return fmt.Errorf("unexpected nil of type %T", v) 6827 } 6828 if value == nil { 6829 return nil 6830 } 6831 6832 shape, ok := value.(map[string]interface{}) 6833 if !ok { 6834 return fmt.Errorf("unexpected JSON type %v", value) 6835 } 6836 6837 var sv *ListAgentsOutput 6838 if *v == nil { 6839 sv = &ListAgentsOutput{} 6840 } else { 6841 sv = *v 6842 } 6843 6844 for key, value := range shape { 6845 switch key { 6846 case "Agents": 6847 if err := awsAwsjson11_deserializeDocumentAgentList(&sv.Agents, value); err != nil { 6848 return err 6849 } 6850 6851 case "NextToken": 6852 if value != nil { 6853 jtv, ok := value.(string) 6854 if !ok { 6855 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6856 } 6857 sv.NextToken = ptr.String(jtv) 6858 } 6859 6860 default: 6861 _, _ = key, value 6862 6863 } 6864 } 6865 *v = sv 6866 return nil 6867} 6868 6869func awsAwsjson11_deserializeOpDocumentListLocationsOutput(v **ListLocationsOutput, value interface{}) error { 6870 if v == nil { 6871 return fmt.Errorf("unexpected nil of type %T", v) 6872 } 6873 if value == nil { 6874 return nil 6875 } 6876 6877 shape, ok := value.(map[string]interface{}) 6878 if !ok { 6879 return fmt.Errorf("unexpected JSON type %v", value) 6880 } 6881 6882 var sv *ListLocationsOutput 6883 if *v == nil { 6884 sv = &ListLocationsOutput{} 6885 } else { 6886 sv = *v 6887 } 6888 6889 for key, value := range shape { 6890 switch key { 6891 case "Locations": 6892 if err := awsAwsjson11_deserializeDocumentLocationList(&sv.Locations, value); err != nil { 6893 return err 6894 } 6895 6896 case "NextToken": 6897 if value != nil { 6898 jtv, ok := value.(string) 6899 if !ok { 6900 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6901 } 6902 sv.NextToken = ptr.String(jtv) 6903 } 6904 6905 default: 6906 _, _ = key, value 6907 6908 } 6909 } 6910 *v = sv 6911 return nil 6912} 6913 6914func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 6915 if v == nil { 6916 return fmt.Errorf("unexpected nil of type %T", v) 6917 } 6918 if value == nil { 6919 return nil 6920 } 6921 6922 shape, ok := value.(map[string]interface{}) 6923 if !ok { 6924 return fmt.Errorf("unexpected JSON type %v", value) 6925 } 6926 6927 var sv *ListTagsForResourceOutput 6928 if *v == nil { 6929 sv = &ListTagsForResourceOutput{} 6930 } else { 6931 sv = *v 6932 } 6933 6934 for key, value := range shape { 6935 switch key { 6936 case "NextToken": 6937 if value != nil { 6938 jtv, ok := value.(string) 6939 if !ok { 6940 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6941 } 6942 sv.NextToken = ptr.String(jtv) 6943 } 6944 6945 case "Tags": 6946 if err := awsAwsjson11_deserializeDocumentOutputTagList(&sv.Tags, value); err != nil { 6947 return err 6948 } 6949 6950 default: 6951 _, _ = key, value 6952 6953 } 6954 } 6955 *v = sv 6956 return nil 6957} 6958 6959func awsAwsjson11_deserializeOpDocumentListTaskExecutionsOutput(v **ListTaskExecutionsOutput, value interface{}) error { 6960 if v == nil { 6961 return fmt.Errorf("unexpected nil of type %T", v) 6962 } 6963 if value == nil { 6964 return nil 6965 } 6966 6967 shape, ok := value.(map[string]interface{}) 6968 if !ok { 6969 return fmt.Errorf("unexpected JSON type %v", value) 6970 } 6971 6972 var sv *ListTaskExecutionsOutput 6973 if *v == nil { 6974 sv = &ListTaskExecutionsOutput{} 6975 } else { 6976 sv = *v 6977 } 6978 6979 for key, value := range shape { 6980 switch key { 6981 case "NextToken": 6982 if value != nil { 6983 jtv, ok := value.(string) 6984 if !ok { 6985 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6986 } 6987 sv.NextToken = ptr.String(jtv) 6988 } 6989 6990 case "TaskExecutions": 6991 if err := awsAwsjson11_deserializeDocumentTaskExecutionList(&sv.TaskExecutions, value); err != nil { 6992 return err 6993 } 6994 6995 default: 6996 _, _ = key, value 6997 6998 } 6999 } 7000 *v = sv 7001 return nil 7002} 7003 7004func awsAwsjson11_deserializeOpDocumentListTasksOutput(v **ListTasksOutput, value interface{}) error { 7005 if v == nil { 7006 return fmt.Errorf("unexpected nil of type %T", v) 7007 } 7008 if value == nil { 7009 return nil 7010 } 7011 7012 shape, ok := value.(map[string]interface{}) 7013 if !ok { 7014 return fmt.Errorf("unexpected JSON type %v", value) 7015 } 7016 7017 var sv *ListTasksOutput 7018 if *v == nil { 7019 sv = &ListTasksOutput{} 7020 } else { 7021 sv = *v 7022 } 7023 7024 for key, value := range shape { 7025 switch key { 7026 case "NextToken": 7027 if value != nil { 7028 jtv, ok := value.(string) 7029 if !ok { 7030 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7031 } 7032 sv.NextToken = ptr.String(jtv) 7033 } 7034 7035 case "Tasks": 7036 if err := awsAwsjson11_deserializeDocumentTaskList(&sv.Tasks, value); err != nil { 7037 return err 7038 } 7039 7040 default: 7041 _, _ = key, value 7042 7043 } 7044 } 7045 *v = sv 7046 return nil 7047} 7048 7049func awsAwsjson11_deserializeOpDocumentStartTaskExecutionOutput(v **StartTaskExecutionOutput, value interface{}) error { 7050 if v == nil { 7051 return fmt.Errorf("unexpected nil of type %T", v) 7052 } 7053 if value == nil { 7054 return nil 7055 } 7056 7057 shape, ok := value.(map[string]interface{}) 7058 if !ok { 7059 return fmt.Errorf("unexpected JSON type %v", value) 7060 } 7061 7062 var sv *StartTaskExecutionOutput 7063 if *v == nil { 7064 sv = &StartTaskExecutionOutput{} 7065 } else { 7066 sv = *v 7067 } 7068 7069 for key, value := range shape { 7070 switch key { 7071 case "TaskExecutionArn": 7072 if value != nil { 7073 jtv, ok := value.(string) 7074 if !ok { 7075 return fmt.Errorf("expected TaskExecutionArn to be of type string, got %T instead", value) 7076 } 7077 sv.TaskExecutionArn = ptr.String(jtv) 7078 } 7079 7080 default: 7081 _, _ = key, value 7082 7083 } 7084 } 7085 *v = sv 7086 return nil 7087} 7088 7089func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 7090 if v == nil { 7091 return fmt.Errorf("unexpected nil of type %T", v) 7092 } 7093 if value == nil { 7094 return nil 7095 } 7096 7097 shape, ok := value.(map[string]interface{}) 7098 if !ok { 7099 return fmt.Errorf("unexpected JSON type %v", value) 7100 } 7101 7102 var sv *TagResourceOutput 7103 if *v == nil { 7104 sv = &TagResourceOutput{} 7105 } else { 7106 sv = *v 7107 } 7108 7109 for key, value := range shape { 7110 switch key { 7111 default: 7112 _, _ = key, value 7113 7114 } 7115 } 7116 *v = sv 7117 return nil 7118} 7119 7120func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 7121 if v == nil { 7122 return fmt.Errorf("unexpected nil of type %T", v) 7123 } 7124 if value == nil { 7125 return nil 7126 } 7127 7128 shape, ok := value.(map[string]interface{}) 7129 if !ok { 7130 return fmt.Errorf("unexpected JSON type %v", value) 7131 } 7132 7133 var sv *UntagResourceOutput 7134 if *v == nil { 7135 sv = &UntagResourceOutput{} 7136 } else { 7137 sv = *v 7138 } 7139 7140 for key, value := range shape { 7141 switch key { 7142 default: 7143 _, _ = key, value 7144 7145 } 7146 } 7147 *v = sv 7148 return nil 7149} 7150 7151func awsAwsjson11_deserializeOpDocumentUpdateAgentOutput(v **UpdateAgentOutput, value interface{}) error { 7152 if v == nil { 7153 return fmt.Errorf("unexpected nil of type %T", v) 7154 } 7155 if value == nil { 7156 return nil 7157 } 7158 7159 shape, ok := value.(map[string]interface{}) 7160 if !ok { 7161 return fmt.Errorf("unexpected JSON type %v", value) 7162 } 7163 7164 var sv *UpdateAgentOutput 7165 if *v == nil { 7166 sv = &UpdateAgentOutput{} 7167 } else { 7168 sv = *v 7169 } 7170 7171 for key, value := range shape { 7172 switch key { 7173 default: 7174 _, _ = key, value 7175 7176 } 7177 } 7178 *v = sv 7179 return nil 7180} 7181 7182func awsAwsjson11_deserializeOpDocumentUpdateLocationNfsOutput(v **UpdateLocationNfsOutput, value interface{}) error { 7183 if v == nil { 7184 return fmt.Errorf("unexpected nil of type %T", v) 7185 } 7186 if value == nil { 7187 return nil 7188 } 7189 7190 shape, ok := value.(map[string]interface{}) 7191 if !ok { 7192 return fmt.Errorf("unexpected JSON type %v", value) 7193 } 7194 7195 var sv *UpdateLocationNfsOutput 7196 if *v == nil { 7197 sv = &UpdateLocationNfsOutput{} 7198 } else { 7199 sv = *v 7200 } 7201 7202 for key, value := range shape { 7203 switch key { 7204 default: 7205 _, _ = key, value 7206 7207 } 7208 } 7209 *v = sv 7210 return nil 7211} 7212 7213func awsAwsjson11_deserializeOpDocumentUpdateLocationObjectStorageOutput(v **UpdateLocationObjectStorageOutput, value interface{}) error { 7214 if v == nil { 7215 return fmt.Errorf("unexpected nil of type %T", v) 7216 } 7217 if value == nil { 7218 return nil 7219 } 7220 7221 shape, ok := value.(map[string]interface{}) 7222 if !ok { 7223 return fmt.Errorf("unexpected JSON type %v", value) 7224 } 7225 7226 var sv *UpdateLocationObjectStorageOutput 7227 if *v == nil { 7228 sv = &UpdateLocationObjectStorageOutput{} 7229 } else { 7230 sv = *v 7231 } 7232 7233 for key, value := range shape { 7234 switch key { 7235 default: 7236 _, _ = key, value 7237 7238 } 7239 } 7240 *v = sv 7241 return nil 7242} 7243 7244func awsAwsjson11_deserializeOpDocumentUpdateLocationSmbOutput(v **UpdateLocationSmbOutput, value interface{}) error { 7245 if v == nil { 7246 return fmt.Errorf("unexpected nil of type %T", v) 7247 } 7248 if value == nil { 7249 return nil 7250 } 7251 7252 shape, ok := value.(map[string]interface{}) 7253 if !ok { 7254 return fmt.Errorf("unexpected JSON type %v", value) 7255 } 7256 7257 var sv *UpdateLocationSmbOutput 7258 if *v == nil { 7259 sv = &UpdateLocationSmbOutput{} 7260 } else { 7261 sv = *v 7262 } 7263 7264 for key, value := range shape { 7265 switch key { 7266 default: 7267 _, _ = key, value 7268 7269 } 7270 } 7271 *v = sv 7272 return nil 7273} 7274 7275func awsAwsjson11_deserializeOpDocumentUpdateTaskExecutionOutput(v **UpdateTaskExecutionOutput, value interface{}) error { 7276 if v == nil { 7277 return fmt.Errorf("unexpected nil of type %T", v) 7278 } 7279 if value == nil { 7280 return nil 7281 } 7282 7283 shape, ok := value.(map[string]interface{}) 7284 if !ok { 7285 return fmt.Errorf("unexpected JSON type %v", value) 7286 } 7287 7288 var sv *UpdateTaskExecutionOutput 7289 if *v == nil { 7290 sv = &UpdateTaskExecutionOutput{} 7291 } else { 7292 sv = *v 7293 } 7294 7295 for key, value := range shape { 7296 switch key { 7297 default: 7298 _, _ = key, value 7299 7300 } 7301 } 7302 *v = sv 7303 return nil 7304} 7305 7306func awsAwsjson11_deserializeOpDocumentUpdateTaskOutput(v **UpdateTaskOutput, value interface{}) error { 7307 if v == nil { 7308 return fmt.Errorf("unexpected nil of type %T", v) 7309 } 7310 if value == nil { 7311 return nil 7312 } 7313 7314 shape, ok := value.(map[string]interface{}) 7315 if !ok { 7316 return fmt.Errorf("unexpected JSON type %v", value) 7317 } 7318 7319 var sv *UpdateTaskOutput 7320 if *v == nil { 7321 sv = &UpdateTaskOutput{} 7322 } else { 7323 sv = *v 7324 } 7325 7326 for key, value := range shape { 7327 switch key { 7328 default: 7329 _, _ = key, value 7330 7331 } 7332 } 7333 *v = sv 7334 return nil 7335} 7336