1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package s3control 4 5import ( 6 "bytes" 7 "context" 8 "encoding/xml" 9 "fmt" 10 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 11 "github.com/aws/aws-sdk-go-v2/service/internal/s3shared" 12 "github.com/aws/aws-sdk-go-v2/service/s3control/types" 13 smithy "github.com/aws/smithy-go" 14 smithyxml "github.com/aws/smithy-go/encoding/xml" 15 smithyio "github.com/aws/smithy-go/io" 16 "github.com/aws/smithy-go/middleware" 17 "github.com/aws/smithy-go/ptr" 18 smithytime "github.com/aws/smithy-go/time" 19 smithyhttp "github.com/aws/smithy-go/transport/http" 20 "io" 21 "io/ioutil" 22 "strconv" 23 "strings" 24) 25 26type awsRestxml_deserializeOpCreateAccessPoint struct { 27} 28 29func (*awsRestxml_deserializeOpCreateAccessPoint) ID() string { 30 return "OperationDeserializer" 31} 32 33func (m *awsRestxml_deserializeOpCreateAccessPoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 34 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 35) { 36 out, metadata, err = next.HandleDeserialize(ctx, in) 37 if err != nil { 38 return out, metadata, err 39 } 40 41 response, ok := out.RawResponse.(*smithyhttp.Response) 42 if !ok { 43 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 44 } 45 46 if response.StatusCode < 200 || response.StatusCode >= 300 { 47 return out, metadata, awsRestxml_deserializeOpErrorCreateAccessPoint(response, &metadata) 48 } 49 output := &CreateAccessPointOutput{} 50 out.Result = output 51 52 var buff [1024]byte 53 ringBuffer := smithyio.NewRingBuffer(buff[:]) 54 body := io.TeeReader(response.Body, ringBuffer) 55 rootDecoder := xml.NewDecoder(body) 56 t, err := smithyxml.FetchRootElement(rootDecoder) 57 if err == io.EOF { 58 return out, metadata, nil 59 } 60 if err != nil { 61 var snapshot bytes.Buffer 62 io.Copy(&snapshot, ringBuffer) 63 return out, metadata, &smithy.DeserializationError{ 64 Err: fmt.Errorf("failed to decode response body, %w", err), 65 Snapshot: snapshot.Bytes(), 66 } 67 } 68 69 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 70 err = awsRestxml_deserializeOpDocumentCreateAccessPointOutput(&output, decoder) 71 if err != nil { 72 var snapshot bytes.Buffer 73 io.Copy(&snapshot, ringBuffer) 74 return out, metadata, &smithy.DeserializationError{ 75 Err: fmt.Errorf("failed to decode response body, %w", err), 76 Snapshot: snapshot.Bytes(), 77 } 78 } 79 80 return out, metadata, err 81} 82 83func awsRestxml_deserializeOpErrorCreateAccessPoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 84 var errorBuffer bytes.Buffer 85 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 86 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 87 } 88 errorBody := bytes.NewReader(errorBuffer.Bytes()) 89 90 errorCode := "UnknownError" 91 errorMessage := errorCode 92 93 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 94 IsWrappedWithErrorTag: true, 95 }) 96 if err != nil { 97 return err 98 } 99 if hostID := errorComponents.HostID; len(hostID) != 0 { 100 s3shared.SetHostIDMetadata(metadata, hostID) 101 } 102 if reqID := errorComponents.RequestID; len(reqID) != 0 { 103 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 104 } 105 if len(errorComponents.Code) != 0 { 106 errorCode = errorComponents.Code 107 } 108 if len(errorComponents.Message) != 0 { 109 errorMessage = errorComponents.Message 110 } 111 errorBody.Seek(0, io.SeekStart) 112 switch { 113 default: 114 genericError := &smithy.GenericAPIError{ 115 Code: errorCode, 116 Message: errorMessage, 117 } 118 return genericError 119 120 } 121} 122 123func awsRestxml_deserializeOpDocumentCreateAccessPointOutput(v **CreateAccessPointOutput, decoder smithyxml.NodeDecoder) error { 124 if v == nil { 125 return fmt.Errorf("unexpected nil of type %T", v) 126 } 127 var sv *CreateAccessPointOutput 128 if *v == nil { 129 sv = &CreateAccessPointOutput{} 130 } else { 131 sv = *v 132 } 133 134 for { 135 t, done, err := decoder.Token() 136 if err != nil { 137 return err 138 } 139 if done { 140 break 141 } 142 originalDecoder := decoder 143 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 144 switch { 145 case strings.EqualFold("AccessPointArn", t.Name.Local): 146 val, err := decoder.Value() 147 if err != nil { 148 return err 149 } 150 if val == nil { 151 break 152 } 153 { 154 xtv := string(val) 155 sv.AccessPointArn = ptr.String(xtv) 156 } 157 158 default: 159 // Do nothing and ignore the unexpected tag element 160 err = decoder.Decoder.Skip() 161 if err != nil { 162 return err 163 } 164 165 } 166 decoder = originalDecoder 167 } 168 *v = sv 169 return nil 170} 171 172type awsRestxml_deserializeOpCreateAccessPointForObjectLambda struct { 173} 174 175func (*awsRestxml_deserializeOpCreateAccessPointForObjectLambda) ID() string { 176 return "OperationDeserializer" 177} 178 179func (m *awsRestxml_deserializeOpCreateAccessPointForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 180 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 181) { 182 out, metadata, err = next.HandleDeserialize(ctx, in) 183 if err != nil { 184 return out, metadata, err 185 } 186 187 response, ok := out.RawResponse.(*smithyhttp.Response) 188 if !ok { 189 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 190 } 191 192 if response.StatusCode < 200 || response.StatusCode >= 300 { 193 return out, metadata, awsRestxml_deserializeOpErrorCreateAccessPointForObjectLambda(response, &metadata) 194 } 195 output := &CreateAccessPointForObjectLambdaOutput{} 196 out.Result = output 197 198 var buff [1024]byte 199 ringBuffer := smithyio.NewRingBuffer(buff[:]) 200 body := io.TeeReader(response.Body, ringBuffer) 201 rootDecoder := xml.NewDecoder(body) 202 t, err := smithyxml.FetchRootElement(rootDecoder) 203 if err == io.EOF { 204 return out, metadata, nil 205 } 206 if err != nil { 207 var snapshot bytes.Buffer 208 io.Copy(&snapshot, ringBuffer) 209 return out, metadata, &smithy.DeserializationError{ 210 Err: fmt.Errorf("failed to decode response body, %w", err), 211 Snapshot: snapshot.Bytes(), 212 } 213 } 214 215 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 216 err = awsRestxml_deserializeOpDocumentCreateAccessPointForObjectLambdaOutput(&output, decoder) 217 if err != nil { 218 var snapshot bytes.Buffer 219 io.Copy(&snapshot, ringBuffer) 220 return out, metadata, &smithy.DeserializationError{ 221 Err: fmt.Errorf("failed to decode response body, %w", err), 222 Snapshot: snapshot.Bytes(), 223 } 224 } 225 226 return out, metadata, err 227} 228 229func awsRestxml_deserializeOpErrorCreateAccessPointForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 230 var errorBuffer bytes.Buffer 231 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 232 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 233 } 234 errorBody := bytes.NewReader(errorBuffer.Bytes()) 235 236 errorCode := "UnknownError" 237 errorMessage := errorCode 238 239 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 240 IsWrappedWithErrorTag: true, 241 }) 242 if err != nil { 243 return err 244 } 245 if hostID := errorComponents.HostID; len(hostID) != 0 { 246 s3shared.SetHostIDMetadata(metadata, hostID) 247 } 248 if reqID := errorComponents.RequestID; len(reqID) != 0 { 249 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 250 } 251 if len(errorComponents.Code) != 0 { 252 errorCode = errorComponents.Code 253 } 254 if len(errorComponents.Message) != 0 { 255 errorMessage = errorComponents.Message 256 } 257 errorBody.Seek(0, io.SeekStart) 258 switch { 259 default: 260 genericError := &smithy.GenericAPIError{ 261 Code: errorCode, 262 Message: errorMessage, 263 } 264 return genericError 265 266 } 267} 268 269func awsRestxml_deserializeOpDocumentCreateAccessPointForObjectLambdaOutput(v **CreateAccessPointForObjectLambdaOutput, decoder smithyxml.NodeDecoder) error { 270 if v == nil { 271 return fmt.Errorf("unexpected nil of type %T", v) 272 } 273 var sv *CreateAccessPointForObjectLambdaOutput 274 if *v == nil { 275 sv = &CreateAccessPointForObjectLambdaOutput{} 276 } else { 277 sv = *v 278 } 279 280 for { 281 t, done, err := decoder.Token() 282 if err != nil { 283 return err 284 } 285 if done { 286 break 287 } 288 originalDecoder := decoder 289 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 290 switch { 291 case strings.EqualFold("ObjectLambdaAccessPointArn", t.Name.Local): 292 val, err := decoder.Value() 293 if err != nil { 294 return err 295 } 296 if val == nil { 297 break 298 } 299 { 300 xtv := string(val) 301 sv.ObjectLambdaAccessPointArn = ptr.String(xtv) 302 } 303 304 default: 305 // Do nothing and ignore the unexpected tag element 306 err = decoder.Decoder.Skip() 307 if err != nil { 308 return err 309 } 310 311 } 312 decoder = originalDecoder 313 } 314 *v = sv 315 return nil 316} 317 318type awsRestxml_deserializeOpCreateBucket struct { 319} 320 321func (*awsRestxml_deserializeOpCreateBucket) ID() string { 322 return "OperationDeserializer" 323} 324 325func (m *awsRestxml_deserializeOpCreateBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 326 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 327) { 328 out, metadata, err = next.HandleDeserialize(ctx, in) 329 if err != nil { 330 return out, metadata, err 331 } 332 333 response, ok := out.RawResponse.(*smithyhttp.Response) 334 if !ok { 335 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 336 } 337 338 if response.StatusCode < 200 || response.StatusCode >= 300 { 339 return out, metadata, awsRestxml_deserializeOpErrorCreateBucket(response, &metadata) 340 } 341 output := &CreateBucketOutput{} 342 out.Result = output 343 344 err = awsRestxml_deserializeOpHttpBindingsCreateBucketOutput(output, response) 345 if err != nil { 346 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 347 } 348 349 var buff [1024]byte 350 ringBuffer := smithyio.NewRingBuffer(buff[:]) 351 body := io.TeeReader(response.Body, ringBuffer) 352 rootDecoder := xml.NewDecoder(body) 353 t, err := smithyxml.FetchRootElement(rootDecoder) 354 if err == io.EOF { 355 return out, metadata, nil 356 } 357 if err != nil { 358 var snapshot bytes.Buffer 359 io.Copy(&snapshot, ringBuffer) 360 return out, metadata, &smithy.DeserializationError{ 361 Err: fmt.Errorf("failed to decode response body, %w", err), 362 Snapshot: snapshot.Bytes(), 363 } 364 } 365 366 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 367 err = awsRestxml_deserializeOpDocumentCreateBucketOutput(&output, decoder) 368 if err != nil { 369 var snapshot bytes.Buffer 370 io.Copy(&snapshot, ringBuffer) 371 return out, metadata, &smithy.DeserializationError{ 372 Err: fmt.Errorf("failed to decode response body, %w", err), 373 Snapshot: snapshot.Bytes(), 374 } 375 } 376 377 return out, metadata, err 378} 379 380func awsRestxml_deserializeOpErrorCreateBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error { 381 var errorBuffer bytes.Buffer 382 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 383 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 384 } 385 errorBody := bytes.NewReader(errorBuffer.Bytes()) 386 387 errorCode := "UnknownError" 388 errorMessage := errorCode 389 390 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 391 IsWrappedWithErrorTag: true, 392 }) 393 if err != nil { 394 return err 395 } 396 if hostID := errorComponents.HostID; len(hostID) != 0 { 397 s3shared.SetHostIDMetadata(metadata, hostID) 398 } 399 if reqID := errorComponents.RequestID; len(reqID) != 0 { 400 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 401 } 402 if len(errorComponents.Code) != 0 { 403 errorCode = errorComponents.Code 404 } 405 if len(errorComponents.Message) != 0 { 406 errorMessage = errorComponents.Message 407 } 408 errorBody.Seek(0, io.SeekStart) 409 switch { 410 case strings.EqualFold("BucketAlreadyExists", errorCode): 411 return awsRestxml_deserializeErrorBucketAlreadyExists(response, errorBody) 412 413 case strings.EqualFold("BucketAlreadyOwnedByYou", errorCode): 414 return awsRestxml_deserializeErrorBucketAlreadyOwnedByYou(response, errorBody) 415 416 default: 417 genericError := &smithy.GenericAPIError{ 418 Code: errorCode, 419 Message: errorMessage, 420 } 421 return genericError 422 423 } 424} 425 426func awsRestxml_deserializeOpHttpBindingsCreateBucketOutput(v *CreateBucketOutput, response *smithyhttp.Response) error { 427 if v == nil { 428 return fmt.Errorf("unsupported deserialization for nil %T", v) 429 } 430 431 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 432 headerValues[0] = strings.TrimSpace(headerValues[0]) 433 v.Location = ptr.String(headerValues[0]) 434 } 435 436 return nil 437} 438func awsRestxml_deserializeOpDocumentCreateBucketOutput(v **CreateBucketOutput, decoder smithyxml.NodeDecoder) error { 439 if v == nil { 440 return fmt.Errorf("unexpected nil of type %T", v) 441 } 442 var sv *CreateBucketOutput 443 if *v == nil { 444 sv = &CreateBucketOutput{} 445 } else { 446 sv = *v 447 } 448 449 for { 450 t, done, err := decoder.Token() 451 if err != nil { 452 return err 453 } 454 if done { 455 break 456 } 457 originalDecoder := decoder 458 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 459 switch { 460 case strings.EqualFold("BucketArn", t.Name.Local): 461 val, err := decoder.Value() 462 if err != nil { 463 return err 464 } 465 if val == nil { 466 break 467 } 468 { 469 xtv := string(val) 470 sv.BucketArn = ptr.String(xtv) 471 } 472 473 default: 474 // Do nothing and ignore the unexpected tag element 475 err = decoder.Decoder.Skip() 476 if err != nil { 477 return err 478 } 479 480 } 481 decoder = originalDecoder 482 } 483 *v = sv 484 return nil 485} 486 487type awsRestxml_deserializeOpCreateJob struct { 488} 489 490func (*awsRestxml_deserializeOpCreateJob) ID() string { 491 return "OperationDeserializer" 492} 493 494func (m *awsRestxml_deserializeOpCreateJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 495 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 496) { 497 out, metadata, err = next.HandleDeserialize(ctx, in) 498 if err != nil { 499 return out, metadata, err 500 } 501 502 response, ok := out.RawResponse.(*smithyhttp.Response) 503 if !ok { 504 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 505 } 506 507 if response.StatusCode < 200 || response.StatusCode >= 300 { 508 return out, metadata, awsRestxml_deserializeOpErrorCreateJob(response, &metadata) 509 } 510 output := &CreateJobOutput{} 511 out.Result = output 512 513 var buff [1024]byte 514 ringBuffer := smithyio.NewRingBuffer(buff[:]) 515 body := io.TeeReader(response.Body, ringBuffer) 516 rootDecoder := xml.NewDecoder(body) 517 t, err := smithyxml.FetchRootElement(rootDecoder) 518 if err == io.EOF { 519 return out, metadata, nil 520 } 521 if err != nil { 522 var snapshot bytes.Buffer 523 io.Copy(&snapshot, ringBuffer) 524 return out, metadata, &smithy.DeserializationError{ 525 Err: fmt.Errorf("failed to decode response body, %w", err), 526 Snapshot: snapshot.Bytes(), 527 } 528 } 529 530 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 531 err = awsRestxml_deserializeOpDocumentCreateJobOutput(&output, decoder) 532 if err != nil { 533 var snapshot bytes.Buffer 534 io.Copy(&snapshot, ringBuffer) 535 return out, metadata, &smithy.DeserializationError{ 536 Err: fmt.Errorf("failed to decode response body, %w", err), 537 Snapshot: snapshot.Bytes(), 538 } 539 } 540 541 return out, metadata, err 542} 543 544func awsRestxml_deserializeOpErrorCreateJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 545 var errorBuffer bytes.Buffer 546 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 547 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 548 } 549 errorBody := bytes.NewReader(errorBuffer.Bytes()) 550 551 errorCode := "UnknownError" 552 errorMessage := errorCode 553 554 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 555 IsWrappedWithErrorTag: true, 556 }) 557 if err != nil { 558 return err 559 } 560 if hostID := errorComponents.HostID; len(hostID) != 0 { 561 s3shared.SetHostIDMetadata(metadata, hostID) 562 } 563 if reqID := errorComponents.RequestID; len(reqID) != 0 { 564 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 565 } 566 if len(errorComponents.Code) != 0 { 567 errorCode = errorComponents.Code 568 } 569 if len(errorComponents.Message) != 0 { 570 errorMessage = errorComponents.Message 571 } 572 errorBody.Seek(0, io.SeekStart) 573 switch { 574 case strings.EqualFold("BadRequestException", errorCode): 575 return awsRestxml_deserializeErrorBadRequestException(response, errorBody) 576 577 case strings.EqualFold("IdempotencyException", errorCode): 578 return awsRestxml_deserializeErrorIdempotencyException(response, errorBody) 579 580 case strings.EqualFold("InternalServiceException", errorCode): 581 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 582 583 case strings.EqualFold("TooManyRequestsException", errorCode): 584 return awsRestxml_deserializeErrorTooManyRequestsException(response, errorBody) 585 586 default: 587 genericError := &smithy.GenericAPIError{ 588 Code: errorCode, 589 Message: errorMessage, 590 } 591 return genericError 592 593 } 594} 595 596func awsRestxml_deserializeOpDocumentCreateJobOutput(v **CreateJobOutput, decoder smithyxml.NodeDecoder) error { 597 if v == nil { 598 return fmt.Errorf("unexpected nil of type %T", v) 599 } 600 var sv *CreateJobOutput 601 if *v == nil { 602 sv = &CreateJobOutput{} 603 } else { 604 sv = *v 605 } 606 607 for { 608 t, done, err := decoder.Token() 609 if err != nil { 610 return err 611 } 612 if done { 613 break 614 } 615 originalDecoder := decoder 616 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 617 switch { 618 case strings.EqualFold("JobId", t.Name.Local): 619 val, err := decoder.Value() 620 if err != nil { 621 return err 622 } 623 if val == nil { 624 break 625 } 626 { 627 xtv := string(val) 628 sv.JobId = ptr.String(xtv) 629 } 630 631 default: 632 // Do nothing and ignore the unexpected tag element 633 err = decoder.Decoder.Skip() 634 if err != nil { 635 return err 636 } 637 638 } 639 decoder = originalDecoder 640 } 641 *v = sv 642 return nil 643} 644 645type awsRestxml_deserializeOpDeleteAccessPoint struct { 646} 647 648func (*awsRestxml_deserializeOpDeleteAccessPoint) ID() string { 649 return "OperationDeserializer" 650} 651 652func (m *awsRestxml_deserializeOpDeleteAccessPoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 653 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 654) { 655 out, metadata, err = next.HandleDeserialize(ctx, in) 656 if err != nil { 657 return out, metadata, err 658 } 659 660 response, ok := out.RawResponse.(*smithyhttp.Response) 661 if !ok { 662 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 663 } 664 665 if response.StatusCode < 200 || response.StatusCode >= 300 { 666 return out, metadata, awsRestxml_deserializeOpErrorDeleteAccessPoint(response, &metadata) 667 } 668 output := &DeleteAccessPointOutput{} 669 out.Result = output 670 671 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 672 return out, metadata, &smithy.DeserializationError{ 673 Err: fmt.Errorf("failed to discard response body, %w", err), 674 } 675 } 676 677 return out, metadata, err 678} 679 680func awsRestxml_deserializeOpErrorDeleteAccessPoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 681 var errorBuffer bytes.Buffer 682 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 683 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 684 } 685 errorBody := bytes.NewReader(errorBuffer.Bytes()) 686 687 errorCode := "UnknownError" 688 errorMessage := errorCode 689 690 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 691 IsWrappedWithErrorTag: true, 692 }) 693 if err != nil { 694 return err 695 } 696 if hostID := errorComponents.HostID; len(hostID) != 0 { 697 s3shared.SetHostIDMetadata(metadata, hostID) 698 } 699 if reqID := errorComponents.RequestID; len(reqID) != 0 { 700 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 701 } 702 if len(errorComponents.Code) != 0 { 703 errorCode = errorComponents.Code 704 } 705 if len(errorComponents.Message) != 0 { 706 errorMessage = errorComponents.Message 707 } 708 errorBody.Seek(0, io.SeekStart) 709 switch { 710 default: 711 genericError := &smithy.GenericAPIError{ 712 Code: errorCode, 713 Message: errorMessage, 714 } 715 return genericError 716 717 } 718} 719 720type awsRestxml_deserializeOpDeleteAccessPointForObjectLambda struct { 721} 722 723func (*awsRestxml_deserializeOpDeleteAccessPointForObjectLambda) ID() string { 724 return "OperationDeserializer" 725} 726 727func (m *awsRestxml_deserializeOpDeleteAccessPointForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 728 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 729) { 730 out, metadata, err = next.HandleDeserialize(ctx, in) 731 if err != nil { 732 return out, metadata, err 733 } 734 735 response, ok := out.RawResponse.(*smithyhttp.Response) 736 if !ok { 737 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 738 } 739 740 if response.StatusCode < 200 || response.StatusCode >= 300 { 741 return out, metadata, awsRestxml_deserializeOpErrorDeleteAccessPointForObjectLambda(response, &metadata) 742 } 743 output := &DeleteAccessPointForObjectLambdaOutput{} 744 out.Result = output 745 746 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 747 return out, metadata, &smithy.DeserializationError{ 748 Err: fmt.Errorf("failed to discard response body, %w", err), 749 } 750 } 751 752 return out, metadata, err 753} 754 755func awsRestxml_deserializeOpErrorDeleteAccessPointForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 756 var errorBuffer bytes.Buffer 757 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 758 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 759 } 760 errorBody := bytes.NewReader(errorBuffer.Bytes()) 761 762 errorCode := "UnknownError" 763 errorMessage := errorCode 764 765 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 766 IsWrappedWithErrorTag: true, 767 }) 768 if err != nil { 769 return err 770 } 771 if hostID := errorComponents.HostID; len(hostID) != 0 { 772 s3shared.SetHostIDMetadata(metadata, hostID) 773 } 774 if reqID := errorComponents.RequestID; len(reqID) != 0 { 775 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 776 } 777 if len(errorComponents.Code) != 0 { 778 errorCode = errorComponents.Code 779 } 780 if len(errorComponents.Message) != 0 { 781 errorMessage = errorComponents.Message 782 } 783 errorBody.Seek(0, io.SeekStart) 784 switch { 785 default: 786 genericError := &smithy.GenericAPIError{ 787 Code: errorCode, 788 Message: errorMessage, 789 } 790 return genericError 791 792 } 793} 794 795type awsRestxml_deserializeOpDeleteAccessPointPolicy struct { 796} 797 798func (*awsRestxml_deserializeOpDeleteAccessPointPolicy) ID() string { 799 return "OperationDeserializer" 800} 801 802func (m *awsRestxml_deserializeOpDeleteAccessPointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 803 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 804) { 805 out, metadata, err = next.HandleDeserialize(ctx, in) 806 if err != nil { 807 return out, metadata, err 808 } 809 810 response, ok := out.RawResponse.(*smithyhttp.Response) 811 if !ok { 812 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 813 } 814 815 if response.StatusCode < 200 || response.StatusCode >= 300 { 816 return out, metadata, awsRestxml_deserializeOpErrorDeleteAccessPointPolicy(response, &metadata) 817 } 818 output := &DeleteAccessPointPolicyOutput{} 819 out.Result = output 820 821 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 822 return out, metadata, &smithy.DeserializationError{ 823 Err: fmt.Errorf("failed to discard response body, %w", err), 824 } 825 } 826 827 return out, metadata, err 828} 829 830func awsRestxml_deserializeOpErrorDeleteAccessPointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 831 var errorBuffer bytes.Buffer 832 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 833 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 834 } 835 errorBody := bytes.NewReader(errorBuffer.Bytes()) 836 837 errorCode := "UnknownError" 838 errorMessage := errorCode 839 840 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 841 IsWrappedWithErrorTag: true, 842 }) 843 if err != nil { 844 return err 845 } 846 if hostID := errorComponents.HostID; len(hostID) != 0 { 847 s3shared.SetHostIDMetadata(metadata, hostID) 848 } 849 if reqID := errorComponents.RequestID; len(reqID) != 0 { 850 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 851 } 852 if len(errorComponents.Code) != 0 { 853 errorCode = errorComponents.Code 854 } 855 if len(errorComponents.Message) != 0 { 856 errorMessage = errorComponents.Message 857 } 858 errorBody.Seek(0, io.SeekStart) 859 switch { 860 default: 861 genericError := &smithy.GenericAPIError{ 862 Code: errorCode, 863 Message: errorMessage, 864 } 865 return genericError 866 867 } 868} 869 870type awsRestxml_deserializeOpDeleteAccessPointPolicyForObjectLambda struct { 871} 872 873func (*awsRestxml_deserializeOpDeleteAccessPointPolicyForObjectLambda) ID() string { 874 return "OperationDeserializer" 875} 876 877func (m *awsRestxml_deserializeOpDeleteAccessPointPolicyForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 878 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 879) { 880 out, metadata, err = next.HandleDeserialize(ctx, in) 881 if err != nil { 882 return out, metadata, err 883 } 884 885 response, ok := out.RawResponse.(*smithyhttp.Response) 886 if !ok { 887 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 888 } 889 890 if response.StatusCode < 200 || response.StatusCode >= 300 { 891 return out, metadata, awsRestxml_deserializeOpErrorDeleteAccessPointPolicyForObjectLambda(response, &metadata) 892 } 893 output := &DeleteAccessPointPolicyForObjectLambdaOutput{} 894 out.Result = output 895 896 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 897 return out, metadata, &smithy.DeserializationError{ 898 Err: fmt.Errorf("failed to discard response body, %w", err), 899 } 900 } 901 902 return out, metadata, err 903} 904 905func awsRestxml_deserializeOpErrorDeleteAccessPointPolicyForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 906 var errorBuffer bytes.Buffer 907 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 908 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 909 } 910 errorBody := bytes.NewReader(errorBuffer.Bytes()) 911 912 errorCode := "UnknownError" 913 errorMessage := errorCode 914 915 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 916 IsWrappedWithErrorTag: true, 917 }) 918 if err != nil { 919 return err 920 } 921 if hostID := errorComponents.HostID; len(hostID) != 0 { 922 s3shared.SetHostIDMetadata(metadata, hostID) 923 } 924 if reqID := errorComponents.RequestID; len(reqID) != 0 { 925 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 926 } 927 if len(errorComponents.Code) != 0 { 928 errorCode = errorComponents.Code 929 } 930 if len(errorComponents.Message) != 0 { 931 errorMessage = errorComponents.Message 932 } 933 errorBody.Seek(0, io.SeekStart) 934 switch { 935 default: 936 genericError := &smithy.GenericAPIError{ 937 Code: errorCode, 938 Message: errorMessage, 939 } 940 return genericError 941 942 } 943} 944 945type awsRestxml_deserializeOpDeleteBucket struct { 946} 947 948func (*awsRestxml_deserializeOpDeleteBucket) ID() string { 949 return "OperationDeserializer" 950} 951 952func (m *awsRestxml_deserializeOpDeleteBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 953 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 954) { 955 out, metadata, err = next.HandleDeserialize(ctx, in) 956 if err != nil { 957 return out, metadata, err 958 } 959 960 response, ok := out.RawResponse.(*smithyhttp.Response) 961 if !ok { 962 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 963 } 964 965 if response.StatusCode < 200 || response.StatusCode >= 300 { 966 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucket(response, &metadata) 967 } 968 output := &DeleteBucketOutput{} 969 out.Result = output 970 971 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 972 return out, metadata, &smithy.DeserializationError{ 973 Err: fmt.Errorf("failed to discard response body, %w", err), 974 } 975 } 976 977 return out, metadata, err 978} 979 980func awsRestxml_deserializeOpErrorDeleteBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error { 981 var errorBuffer bytes.Buffer 982 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 983 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 984 } 985 errorBody := bytes.NewReader(errorBuffer.Bytes()) 986 987 errorCode := "UnknownError" 988 errorMessage := errorCode 989 990 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 991 IsWrappedWithErrorTag: true, 992 }) 993 if err != nil { 994 return err 995 } 996 if hostID := errorComponents.HostID; len(hostID) != 0 { 997 s3shared.SetHostIDMetadata(metadata, hostID) 998 } 999 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1000 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1001 } 1002 if len(errorComponents.Code) != 0 { 1003 errorCode = errorComponents.Code 1004 } 1005 if len(errorComponents.Message) != 0 { 1006 errorMessage = errorComponents.Message 1007 } 1008 errorBody.Seek(0, io.SeekStart) 1009 switch { 1010 default: 1011 genericError := &smithy.GenericAPIError{ 1012 Code: errorCode, 1013 Message: errorMessage, 1014 } 1015 return genericError 1016 1017 } 1018} 1019 1020type awsRestxml_deserializeOpDeleteBucketLifecycleConfiguration struct { 1021} 1022 1023func (*awsRestxml_deserializeOpDeleteBucketLifecycleConfiguration) ID() string { 1024 return "OperationDeserializer" 1025} 1026 1027func (m *awsRestxml_deserializeOpDeleteBucketLifecycleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1028 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1029) { 1030 out, metadata, err = next.HandleDeserialize(ctx, in) 1031 if err != nil { 1032 return out, metadata, err 1033 } 1034 1035 response, ok := out.RawResponse.(*smithyhttp.Response) 1036 if !ok { 1037 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1038 } 1039 1040 if response.StatusCode < 200 || response.StatusCode >= 300 { 1041 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketLifecycleConfiguration(response, &metadata) 1042 } 1043 output := &DeleteBucketLifecycleConfigurationOutput{} 1044 out.Result = output 1045 1046 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1047 return out, metadata, &smithy.DeserializationError{ 1048 Err: fmt.Errorf("failed to discard response body, %w", err), 1049 } 1050 } 1051 1052 return out, metadata, err 1053} 1054 1055func awsRestxml_deserializeOpErrorDeleteBucketLifecycleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1056 var errorBuffer bytes.Buffer 1057 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1058 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1059 } 1060 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1061 1062 errorCode := "UnknownError" 1063 errorMessage := errorCode 1064 1065 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1066 IsWrappedWithErrorTag: true, 1067 }) 1068 if err != nil { 1069 return err 1070 } 1071 if hostID := errorComponents.HostID; len(hostID) != 0 { 1072 s3shared.SetHostIDMetadata(metadata, hostID) 1073 } 1074 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1075 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1076 } 1077 if len(errorComponents.Code) != 0 { 1078 errorCode = errorComponents.Code 1079 } 1080 if len(errorComponents.Message) != 0 { 1081 errorMessage = errorComponents.Message 1082 } 1083 errorBody.Seek(0, io.SeekStart) 1084 switch { 1085 default: 1086 genericError := &smithy.GenericAPIError{ 1087 Code: errorCode, 1088 Message: errorMessage, 1089 } 1090 return genericError 1091 1092 } 1093} 1094 1095type awsRestxml_deserializeOpDeleteBucketPolicy struct { 1096} 1097 1098func (*awsRestxml_deserializeOpDeleteBucketPolicy) ID() string { 1099 return "OperationDeserializer" 1100} 1101 1102func (m *awsRestxml_deserializeOpDeleteBucketPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1103 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1104) { 1105 out, metadata, err = next.HandleDeserialize(ctx, in) 1106 if err != nil { 1107 return out, metadata, err 1108 } 1109 1110 response, ok := out.RawResponse.(*smithyhttp.Response) 1111 if !ok { 1112 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1113 } 1114 1115 if response.StatusCode < 200 || response.StatusCode >= 300 { 1116 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketPolicy(response, &metadata) 1117 } 1118 output := &DeleteBucketPolicyOutput{} 1119 out.Result = output 1120 1121 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1122 return out, metadata, &smithy.DeserializationError{ 1123 Err: fmt.Errorf("failed to discard response body, %w", err), 1124 } 1125 } 1126 1127 return out, metadata, err 1128} 1129 1130func awsRestxml_deserializeOpErrorDeleteBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1131 var errorBuffer bytes.Buffer 1132 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1133 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1134 } 1135 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1136 1137 errorCode := "UnknownError" 1138 errorMessage := errorCode 1139 1140 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1141 IsWrappedWithErrorTag: true, 1142 }) 1143 if err != nil { 1144 return err 1145 } 1146 if hostID := errorComponents.HostID; len(hostID) != 0 { 1147 s3shared.SetHostIDMetadata(metadata, hostID) 1148 } 1149 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1150 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1151 } 1152 if len(errorComponents.Code) != 0 { 1153 errorCode = errorComponents.Code 1154 } 1155 if len(errorComponents.Message) != 0 { 1156 errorMessage = errorComponents.Message 1157 } 1158 errorBody.Seek(0, io.SeekStart) 1159 switch { 1160 default: 1161 genericError := &smithy.GenericAPIError{ 1162 Code: errorCode, 1163 Message: errorMessage, 1164 } 1165 return genericError 1166 1167 } 1168} 1169 1170type awsRestxml_deserializeOpDeleteBucketTagging struct { 1171} 1172 1173func (*awsRestxml_deserializeOpDeleteBucketTagging) ID() string { 1174 return "OperationDeserializer" 1175} 1176 1177func (m *awsRestxml_deserializeOpDeleteBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1178 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1179) { 1180 out, metadata, err = next.HandleDeserialize(ctx, in) 1181 if err != nil { 1182 return out, metadata, err 1183 } 1184 1185 response, ok := out.RawResponse.(*smithyhttp.Response) 1186 if !ok { 1187 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1188 } 1189 1190 if response.StatusCode < 200 || response.StatusCode >= 300 { 1191 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketTagging(response, &metadata) 1192 } 1193 output := &DeleteBucketTaggingOutput{} 1194 out.Result = output 1195 1196 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1197 return out, metadata, &smithy.DeserializationError{ 1198 Err: fmt.Errorf("failed to discard response body, %w", err), 1199 } 1200 } 1201 1202 return out, metadata, err 1203} 1204 1205func awsRestxml_deserializeOpErrorDeleteBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1206 var errorBuffer bytes.Buffer 1207 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1208 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1209 } 1210 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1211 1212 errorCode := "UnknownError" 1213 errorMessage := errorCode 1214 1215 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1216 IsWrappedWithErrorTag: true, 1217 }) 1218 if err != nil { 1219 return err 1220 } 1221 if hostID := errorComponents.HostID; len(hostID) != 0 { 1222 s3shared.SetHostIDMetadata(metadata, hostID) 1223 } 1224 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1225 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1226 } 1227 if len(errorComponents.Code) != 0 { 1228 errorCode = errorComponents.Code 1229 } 1230 if len(errorComponents.Message) != 0 { 1231 errorMessage = errorComponents.Message 1232 } 1233 errorBody.Seek(0, io.SeekStart) 1234 switch { 1235 default: 1236 genericError := &smithy.GenericAPIError{ 1237 Code: errorCode, 1238 Message: errorMessage, 1239 } 1240 return genericError 1241 1242 } 1243} 1244 1245type awsRestxml_deserializeOpDeleteJobTagging struct { 1246} 1247 1248func (*awsRestxml_deserializeOpDeleteJobTagging) ID() string { 1249 return "OperationDeserializer" 1250} 1251 1252func (m *awsRestxml_deserializeOpDeleteJobTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1253 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1254) { 1255 out, metadata, err = next.HandleDeserialize(ctx, in) 1256 if err != nil { 1257 return out, metadata, err 1258 } 1259 1260 response, ok := out.RawResponse.(*smithyhttp.Response) 1261 if !ok { 1262 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1263 } 1264 1265 if response.StatusCode < 200 || response.StatusCode >= 300 { 1266 return out, metadata, awsRestxml_deserializeOpErrorDeleteJobTagging(response, &metadata) 1267 } 1268 output := &DeleteJobTaggingOutput{} 1269 out.Result = output 1270 1271 return out, metadata, err 1272} 1273 1274func awsRestxml_deserializeOpErrorDeleteJobTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1275 var errorBuffer bytes.Buffer 1276 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1277 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1278 } 1279 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1280 1281 errorCode := "UnknownError" 1282 errorMessage := errorCode 1283 1284 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1285 IsWrappedWithErrorTag: true, 1286 }) 1287 if err != nil { 1288 return err 1289 } 1290 if hostID := errorComponents.HostID; len(hostID) != 0 { 1291 s3shared.SetHostIDMetadata(metadata, hostID) 1292 } 1293 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1294 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1295 } 1296 if len(errorComponents.Code) != 0 { 1297 errorCode = errorComponents.Code 1298 } 1299 if len(errorComponents.Message) != 0 { 1300 errorMessage = errorComponents.Message 1301 } 1302 errorBody.Seek(0, io.SeekStart) 1303 switch { 1304 case strings.EqualFold("InternalServiceException", errorCode): 1305 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 1306 1307 case strings.EqualFold("NotFoundException", errorCode): 1308 return awsRestxml_deserializeErrorNotFoundException(response, errorBody) 1309 1310 case strings.EqualFold("TooManyRequestsException", errorCode): 1311 return awsRestxml_deserializeErrorTooManyRequestsException(response, errorBody) 1312 1313 default: 1314 genericError := &smithy.GenericAPIError{ 1315 Code: errorCode, 1316 Message: errorMessage, 1317 } 1318 return genericError 1319 1320 } 1321} 1322 1323type awsRestxml_deserializeOpDeletePublicAccessBlock struct { 1324} 1325 1326func (*awsRestxml_deserializeOpDeletePublicAccessBlock) ID() string { 1327 return "OperationDeserializer" 1328} 1329 1330func (m *awsRestxml_deserializeOpDeletePublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1331 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1332) { 1333 out, metadata, err = next.HandleDeserialize(ctx, in) 1334 if err != nil { 1335 return out, metadata, err 1336 } 1337 1338 response, ok := out.RawResponse.(*smithyhttp.Response) 1339 if !ok { 1340 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1341 } 1342 1343 if response.StatusCode < 200 || response.StatusCode >= 300 { 1344 return out, metadata, awsRestxml_deserializeOpErrorDeletePublicAccessBlock(response, &metadata) 1345 } 1346 output := &DeletePublicAccessBlockOutput{} 1347 out.Result = output 1348 1349 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1350 return out, metadata, &smithy.DeserializationError{ 1351 Err: fmt.Errorf("failed to discard response body, %w", err), 1352 } 1353 } 1354 1355 return out, metadata, err 1356} 1357 1358func awsRestxml_deserializeOpErrorDeletePublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1359 var errorBuffer bytes.Buffer 1360 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1361 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1362 } 1363 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1364 1365 errorCode := "UnknownError" 1366 errorMessage := errorCode 1367 1368 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1369 IsWrappedWithErrorTag: true, 1370 }) 1371 if err != nil { 1372 return err 1373 } 1374 if hostID := errorComponents.HostID; len(hostID) != 0 { 1375 s3shared.SetHostIDMetadata(metadata, hostID) 1376 } 1377 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1378 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1379 } 1380 if len(errorComponents.Code) != 0 { 1381 errorCode = errorComponents.Code 1382 } 1383 if len(errorComponents.Message) != 0 { 1384 errorMessage = errorComponents.Message 1385 } 1386 errorBody.Seek(0, io.SeekStart) 1387 switch { 1388 default: 1389 genericError := &smithy.GenericAPIError{ 1390 Code: errorCode, 1391 Message: errorMessage, 1392 } 1393 return genericError 1394 1395 } 1396} 1397 1398type awsRestxml_deserializeOpDeleteStorageLensConfiguration struct { 1399} 1400 1401func (*awsRestxml_deserializeOpDeleteStorageLensConfiguration) ID() string { 1402 return "OperationDeserializer" 1403} 1404 1405func (m *awsRestxml_deserializeOpDeleteStorageLensConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1406 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1407) { 1408 out, metadata, err = next.HandleDeserialize(ctx, in) 1409 if err != nil { 1410 return out, metadata, err 1411 } 1412 1413 response, ok := out.RawResponse.(*smithyhttp.Response) 1414 if !ok { 1415 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1416 } 1417 1418 if response.StatusCode < 200 || response.StatusCode >= 300 { 1419 return out, metadata, awsRestxml_deserializeOpErrorDeleteStorageLensConfiguration(response, &metadata) 1420 } 1421 output := &DeleteStorageLensConfigurationOutput{} 1422 out.Result = output 1423 1424 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1425 return out, metadata, &smithy.DeserializationError{ 1426 Err: fmt.Errorf("failed to discard response body, %w", err), 1427 } 1428 } 1429 1430 return out, metadata, err 1431} 1432 1433func awsRestxml_deserializeOpErrorDeleteStorageLensConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1434 var errorBuffer bytes.Buffer 1435 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1436 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1437 } 1438 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1439 1440 errorCode := "UnknownError" 1441 errorMessage := errorCode 1442 1443 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1444 IsWrappedWithErrorTag: true, 1445 }) 1446 if err != nil { 1447 return err 1448 } 1449 if hostID := errorComponents.HostID; len(hostID) != 0 { 1450 s3shared.SetHostIDMetadata(metadata, hostID) 1451 } 1452 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1453 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1454 } 1455 if len(errorComponents.Code) != 0 { 1456 errorCode = errorComponents.Code 1457 } 1458 if len(errorComponents.Message) != 0 { 1459 errorMessage = errorComponents.Message 1460 } 1461 errorBody.Seek(0, io.SeekStart) 1462 switch { 1463 default: 1464 genericError := &smithy.GenericAPIError{ 1465 Code: errorCode, 1466 Message: errorMessage, 1467 } 1468 return genericError 1469 1470 } 1471} 1472 1473type awsRestxml_deserializeOpDeleteStorageLensConfigurationTagging struct { 1474} 1475 1476func (*awsRestxml_deserializeOpDeleteStorageLensConfigurationTagging) ID() string { 1477 return "OperationDeserializer" 1478} 1479 1480func (m *awsRestxml_deserializeOpDeleteStorageLensConfigurationTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1481 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1482) { 1483 out, metadata, err = next.HandleDeserialize(ctx, in) 1484 if err != nil { 1485 return out, metadata, err 1486 } 1487 1488 response, ok := out.RawResponse.(*smithyhttp.Response) 1489 if !ok { 1490 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1491 } 1492 1493 if response.StatusCode < 200 || response.StatusCode >= 300 { 1494 return out, metadata, awsRestxml_deserializeOpErrorDeleteStorageLensConfigurationTagging(response, &metadata) 1495 } 1496 output := &DeleteStorageLensConfigurationTaggingOutput{} 1497 out.Result = output 1498 1499 return out, metadata, err 1500} 1501 1502func awsRestxml_deserializeOpErrorDeleteStorageLensConfigurationTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1503 var errorBuffer bytes.Buffer 1504 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1505 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1506 } 1507 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1508 1509 errorCode := "UnknownError" 1510 errorMessage := errorCode 1511 1512 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1513 IsWrappedWithErrorTag: true, 1514 }) 1515 if err != nil { 1516 return err 1517 } 1518 if hostID := errorComponents.HostID; len(hostID) != 0 { 1519 s3shared.SetHostIDMetadata(metadata, hostID) 1520 } 1521 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1522 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1523 } 1524 if len(errorComponents.Code) != 0 { 1525 errorCode = errorComponents.Code 1526 } 1527 if len(errorComponents.Message) != 0 { 1528 errorMessage = errorComponents.Message 1529 } 1530 errorBody.Seek(0, io.SeekStart) 1531 switch { 1532 default: 1533 genericError := &smithy.GenericAPIError{ 1534 Code: errorCode, 1535 Message: errorMessage, 1536 } 1537 return genericError 1538 1539 } 1540} 1541 1542type awsRestxml_deserializeOpDescribeJob struct { 1543} 1544 1545func (*awsRestxml_deserializeOpDescribeJob) ID() string { 1546 return "OperationDeserializer" 1547} 1548 1549func (m *awsRestxml_deserializeOpDescribeJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1550 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1551) { 1552 out, metadata, err = next.HandleDeserialize(ctx, in) 1553 if err != nil { 1554 return out, metadata, err 1555 } 1556 1557 response, ok := out.RawResponse.(*smithyhttp.Response) 1558 if !ok { 1559 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1560 } 1561 1562 if response.StatusCode < 200 || response.StatusCode >= 300 { 1563 return out, metadata, awsRestxml_deserializeOpErrorDescribeJob(response, &metadata) 1564 } 1565 output := &DescribeJobOutput{} 1566 out.Result = output 1567 1568 var buff [1024]byte 1569 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1570 body := io.TeeReader(response.Body, ringBuffer) 1571 rootDecoder := xml.NewDecoder(body) 1572 t, err := smithyxml.FetchRootElement(rootDecoder) 1573 if err == io.EOF { 1574 return out, metadata, nil 1575 } 1576 if err != nil { 1577 var snapshot bytes.Buffer 1578 io.Copy(&snapshot, ringBuffer) 1579 return out, metadata, &smithy.DeserializationError{ 1580 Err: fmt.Errorf("failed to decode response body, %w", err), 1581 Snapshot: snapshot.Bytes(), 1582 } 1583 } 1584 1585 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1586 err = awsRestxml_deserializeOpDocumentDescribeJobOutput(&output, decoder) 1587 if err != nil { 1588 var snapshot bytes.Buffer 1589 io.Copy(&snapshot, ringBuffer) 1590 return out, metadata, &smithy.DeserializationError{ 1591 Err: fmt.Errorf("failed to decode response body, %w", err), 1592 Snapshot: snapshot.Bytes(), 1593 } 1594 } 1595 1596 return out, metadata, err 1597} 1598 1599func awsRestxml_deserializeOpErrorDescribeJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1600 var errorBuffer bytes.Buffer 1601 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1602 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1603 } 1604 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1605 1606 errorCode := "UnknownError" 1607 errorMessage := errorCode 1608 1609 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1610 IsWrappedWithErrorTag: true, 1611 }) 1612 if err != nil { 1613 return err 1614 } 1615 if hostID := errorComponents.HostID; len(hostID) != 0 { 1616 s3shared.SetHostIDMetadata(metadata, hostID) 1617 } 1618 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1619 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1620 } 1621 if len(errorComponents.Code) != 0 { 1622 errorCode = errorComponents.Code 1623 } 1624 if len(errorComponents.Message) != 0 { 1625 errorMessage = errorComponents.Message 1626 } 1627 errorBody.Seek(0, io.SeekStart) 1628 switch { 1629 case strings.EqualFold("BadRequestException", errorCode): 1630 return awsRestxml_deserializeErrorBadRequestException(response, errorBody) 1631 1632 case strings.EqualFold("InternalServiceException", errorCode): 1633 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 1634 1635 case strings.EqualFold("NotFoundException", errorCode): 1636 return awsRestxml_deserializeErrorNotFoundException(response, errorBody) 1637 1638 case strings.EqualFold("TooManyRequestsException", errorCode): 1639 return awsRestxml_deserializeErrorTooManyRequestsException(response, errorBody) 1640 1641 default: 1642 genericError := &smithy.GenericAPIError{ 1643 Code: errorCode, 1644 Message: errorMessage, 1645 } 1646 return genericError 1647 1648 } 1649} 1650 1651func awsRestxml_deserializeOpDocumentDescribeJobOutput(v **DescribeJobOutput, decoder smithyxml.NodeDecoder) error { 1652 if v == nil { 1653 return fmt.Errorf("unexpected nil of type %T", v) 1654 } 1655 var sv *DescribeJobOutput 1656 if *v == nil { 1657 sv = &DescribeJobOutput{} 1658 } else { 1659 sv = *v 1660 } 1661 1662 for { 1663 t, done, err := decoder.Token() 1664 if err != nil { 1665 return err 1666 } 1667 if done { 1668 break 1669 } 1670 originalDecoder := decoder 1671 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1672 switch { 1673 case strings.EqualFold("Job", t.Name.Local): 1674 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1675 if err := awsRestxml_deserializeDocumentJobDescriptor(&sv.Job, nodeDecoder); err != nil { 1676 return err 1677 } 1678 1679 default: 1680 // Do nothing and ignore the unexpected tag element 1681 err = decoder.Decoder.Skip() 1682 if err != nil { 1683 return err 1684 } 1685 1686 } 1687 decoder = originalDecoder 1688 } 1689 *v = sv 1690 return nil 1691} 1692 1693type awsRestxml_deserializeOpGetAccessPoint struct { 1694} 1695 1696func (*awsRestxml_deserializeOpGetAccessPoint) ID() string { 1697 return "OperationDeserializer" 1698} 1699 1700func (m *awsRestxml_deserializeOpGetAccessPoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1701 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1702) { 1703 out, metadata, err = next.HandleDeserialize(ctx, in) 1704 if err != nil { 1705 return out, metadata, err 1706 } 1707 1708 response, ok := out.RawResponse.(*smithyhttp.Response) 1709 if !ok { 1710 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1711 } 1712 1713 if response.StatusCode < 200 || response.StatusCode >= 300 { 1714 return out, metadata, awsRestxml_deserializeOpErrorGetAccessPoint(response, &metadata) 1715 } 1716 output := &GetAccessPointOutput{} 1717 out.Result = output 1718 1719 var buff [1024]byte 1720 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1721 body := io.TeeReader(response.Body, ringBuffer) 1722 rootDecoder := xml.NewDecoder(body) 1723 t, err := smithyxml.FetchRootElement(rootDecoder) 1724 if err == io.EOF { 1725 return out, metadata, nil 1726 } 1727 if err != nil { 1728 var snapshot bytes.Buffer 1729 io.Copy(&snapshot, ringBuffer) 1730 return out, metadata, &smithy.DeserializationError{ 1731 Err: fmt.Errorf("failed to decode response body, %w", err), 1732 Snapshot: snapshot.Bytes(), 1733 } 1734 } 1735 1736 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1737 err = awsRestxml_deserializeOpDocumentGetAccessPointOutput(&output, decoder) 1738 if err != nil { 1739 var snapshot bytes.Buffer 1740 io.Copy(&snapshot, ringBuffer) 1741 return out, metadata, &smithy.DeserializationError{ 1742 Err: fmt.Errorf("failed to decode response body, %w", err), 1743 Snapshot: snapshot.Bytes(), 1744 } 1745 } 1746 1747 return out, metadata, err 1748} 1749 1750func awsRestxml_deserializeOpErrorGetAccessPoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1751 var errorBuffer bytes.Buffer 1752 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1753 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1754 } 1755 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1756 1757 errorCode := "UnknownError" 1758 errorMessage := errorCode 1759 1760 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1761 IsWrappedWithErrorTag: true, 1762 }) 1763 if err != nil { 1764 return err 1765 } 1766 if hostID := errorComponents.HostID; len(hostID) != 0 { 1767 s3shared.SetHostIDMetadata(metadata, hostID) 1768 } 1769 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1770 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1771 } 1772 if len(errorComponents.Code) != 0 { 1773 errorCode = errorComponents.Code 1774 } 1775 if len(errorComponents.Message) != 0 { 1776 errorMessage = errorComponents.Message 1777 } 1778 errorBody.Seek(0, io.SeekStart) 1779 switch { 1780 default: 1781 genericError := &smithy.GenericAPIError{ 1782 Code: errorCode, 1783 Message: errorMessage, 1784 } 1785 return genericError 1786 1787 } 1788} 1789 1790func awsRestxml_deserializeOpDocumentGetAccessPointOutput(v **GetAccessPointOutput, decoder smithyxml.NodeDecoder) error { 1791 if v == nil { 1792 return fmt.Errorf("unexpected nil of type %T", v) 1793 } 1794 var sv *GetAccessPointOutput 1795 if *v == nil { 1796 sv = &GetAccessPointOutput{} 1797 } else { 1798 sv = *v 1799 } 1800 1801 for { 1802 t, done, err := decoder.Token() 1803 if err != nil { 1804 return err 1805 } 1806 if done { 1807 break 1808 } 1809 originalDecoder := decoder 1810 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1811 switch { 1812 case strings.EqualFold("Bucket", t.Name.Local): 1813 val, err := decoder.Value() 1814 if err != nil { 1815 return err 1816 } 1817 if val == nil { 1818 break 1819 } 1820 { 1821 xtv := string(val) 1822 sv.Bucket = ptr.String(xtv) 1823 } 1824 1825 case strings.EqualFold("CreationDate", t.Name.Local): 1826 val, err := decoder.Value() 1827 if err != nil { 1828 return err 1829 } 1830 if val == nil { 1831 break 1832 } 1833 { 1834 xtv := string(val) 1835 t, err := smithytime.ParseDateTime(xtv) 1836 if err != nil { 1837 return err 1838 } 1839 sv.CreationDate = ptr.Time(t) 1840 } 1841 1842 case strings.EqualFold("Name", t.Name.Local): 1843 val, err := decoder.Value() 1844 if err != nil { 1845 return err 1846 } 1847 if val == nil { 1848 break 1849 } 1850 { 1851 xtv := string(val) 1852 sv.Name = ptr.String(xtv) 1853 } 1854 1855 case strings.EqualFold("NetworkOrigin", t.Name.Local): 1856 val, err := decoder.Value() 1857 if err != nil { 1858 return err 1859 } 1860 if val == nil { 1861 break 1862 } 1863 { 1864 xtv := string(val) 1865 sv.NetworkOrigin = types.NetworkOrigin(xtv) 1866 } 1867 1868 case strings.EqualFold("PublicAccessBlockConfiguration", t.Name.Local): 1869 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1870 if err := awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&sv.PublicAccessBlockConfiguration, nodeDecoder); err != nil { 1871 return err 1872 } 1873 1874 case strings.EqualFold("VpcConfiguration", t.Name.Local): 1875 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1876 if err := awsRestxml_deserializeDocumentVpcConfiguration(&sv.VpcConfiguration, nodeDecoder); err != nil { 1877 return err 1878 } 1879 1880 default: 1881 // Do nothing and ignore the unexpected tag element 1882 err = decoder.Decoder.Skip() 1883 if err != nil { 1884 return err 1885 } 1886 1887 } 1888 decoder = originalDecoder 1889 } 1890 *v = sv 1891 return nil 1892} 1893 1894type awsRestxml_deserializeOpGetAccessPointConfigurationForObjectLambda struct { 1895} 1896 1897func (*awsRestxml_deserializeOpGetAccessPointConfigurationForObjectLambda) ID() string { 1898 return "OperationDeserializer" 1899} 1900 1901func (m *awsRestxml_deserializeOpGetAccessPointConfigurationForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1902 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1903) { 1904 out, metadata, err = next.HandleDeserialize(ctx, in) 1905 if err != nil { 1906 return out, metadata, err 1907 } 1908 1909 response, ok := out.RawResponse.(*smithyhttp.Response) 1910 if !ok { 1911 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1912 } 1913 1914 if response.StatusCode < 200 || response.StatusCode >= 300 { 1915 return out, metadata, awsRestxml_deserializeOpErrorGetAccessPointConfigurationForObjectLambda(response, &metadata) 1916 } 1917 output := &GetAccessPointConfigurationForObjectLambdaOutput{} 1918 out.Result = output 1919 1920 var buff [1024]byte 1921 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1922 body := io.TeeReader(response.Body, ringBuffer) 1923 rootDecoder := xml.NewDecoder(body) 1924 t, err := smithyxml.FetchRootElement(rootDecoder) 1925 if err == io.EOF { 1926 return out, metadata, nil 1927 } 1928 if err != nil { 1929 var snapshot bytes.Buffer 1930 io.Copy(&snapshot, ringBuffer) 1931 return out, metadata, &smithy.DeserializationError{ 1932 Err: fmt.Errorf("failed to decode response body, %w", err), 1933 Snapshot: snapshot.Bytes(), 1934 } 1935 } 1936 1937 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1938 err = awsRestxml_deserializeOpDocumentGetAccessPointConfigurationForObjectLambdaOutput(&output, decoder) 1939 if err != nil { 1940 var snapshot bytes.Buffer 1941 io.Copy(&snapshot, ringBuffer) 1942 return out, metadata, &smithy.DeserializationError{ 1943 Err: fmt.Errorf("failed to decode response body, %w", err), 1944 Snapshot: snapshot.Bytes(), 1945 } 1946 } 1947 1948 return out, metadata, err 1949} 1950 1951func awsRestxml_deserializeOpErrorGetAccessPointConfigurationForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1952 var errorBuffer bytes.Buffer 1953 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1954 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1955 } 1956 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1957 1958 errorCode := "UnknownError" 1959 errorMessage := errorCode 1960 1961 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1962 IsWrappedWithErrorTag: true, 1963 }) 1964 if err != nil { 1965 return err 1966 } 1967 if hostID := errorComponents.HostID; len(hostID) != 0 { 1968 s3shared.SetHostIDMetadata(metadata, hostID) 1969 } 1970 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1971 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1972 } 1973 if len(errorComponents.Code) != 0 { 1974 errorCode = errorComponents.Code 1975 } 1976 if len(errorComponents.Message) != 0 { 1977 errorMessage = errorComponents.Message 1978 } 1979 errorBody.Seek(0, io.SeekStart) 1980 switch { 1981 default: 1982 genericError := &smithy.GenericAPIError{ 1983 Code: errorCode, 1984 Message: errorMessage, 1985 } 1986 return genericError 1987 1988 } 1989} 1990 1991func awsRestxml_deserializeOpDocumentGetAccessPointConfigurationForObjectLambdaOutput(v **GetAccessPointConfigurationForObjectLambdaOutput, decoder smithyxml.NodeDecoder) error { 1992 if v == nil { 1993 return fmt.Errorf("unexpected nil of type %T", v) 1994 } 1995 var sv *GetAccessPointConfigurationForObjectLambdaOutput 1996 if *v == nil { 1997 sv = &GetAccessPointConfigurationForObjectLambdaOutput{} 1998 } else { 1999 sv = *v 2000 } 2001 2002 for { 2003 t, done, err := decoder.Token() 2004 if err != nil { 2005 return err 2006 } 2007 if done { 2008 break 2009 } 2010 originalDecoder := decoder 2011 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2012 switch { 2013 case strings.EqualFold("Configuration", t.Name.Local): 2014 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2015 if err := awsRestxml_deserializeDocumentObjectLambdaConfiguration(&sv.Configuration, nodeDecoder); err != nil { 2016 return err 2017 } 2018 2019 default: 2020 // Do nothing and ignore the unexpected tag element 2021 err = decoder.Decoder.Skip() 2022 if err != nil { 2023 return err 2024 } 2025 2026 } 2027 decoder = originalDecoder 2028 } 2029 *v = sv 2030 return nil 2031} 2032 2033type awsRestxml_deserializeOpGetAccessPointForObjectLambda struct { 2034} 2035 2036func (*awsRestxml_deserializeOpGetAccessPointForObjectLambda) ID() string { 2037 return "OperationDeserializer" 2038} 2039 2040func (m *awsRestxml_deserializeOpGetAccessPointForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2041 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2042) { 2043 out, metadata, err = next.HandleDeserialize(ctx, in) 2044 if err != nil { 2045 return out, metadata, err 2046 } 2047 2048 response, ok := out.RawResponse.(*smithyhttp.Response) 2049 if !ok { 2050 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2051 } 2052 2053 if response.StatusCode < 200 || response.StatusCode >= 300 { 2054 return out, metadata, awsRestxml_deserializeOpErrorGetAccessPointForObjectLambda(response, &metadata) 2055 } 2056 output := &GetAccessPointForObjectLambdaOutput{} 2057 out.Result = output 2058 2059 var buff [1024]byte 2060 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2061 body := io.TeeReader(response.Body, ringBuffer) 2062 rootDecoder := xml.NewDecoder(body) 2063 t, err := smithyxml.FetchRootElement(rootDecoder) 2064 if err == io.EOF { 2065 return out, metadata, nil 2066 } 2067 if err != nil { 2068 var snapshot bytes.Buffer 2069 io.Copy(&snapshot, ringBuffer) 2070 return out, metadata, &smithy.DeserializationError{ 2071 Err: fmt.Errorf("failed to decode response body, %w", err), 2072 Snapshot: snapshot.Bytes(), 2073 } 2074 } 2075 2076 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2077 err = awsRestxml_deserializeOpDocumentGetAccessPointForObjectLambdaOutput(&output, decoder) 2078 if err != nil { 2079 var snapshot bytes.Buffer 2080 io.Copy(&snapshot, ringBuffer) 2081 return out, metadata, &smithy.DeserializationError{ 2082 Err: fmt.Errorf("failed to decode response body, %w", err), 2083 Snapshot: snapshot.Bytes(), 2084 } 2085 } 2086 2087 return out, metadata, err 2088} 2089 2090func awsRestxml_deserializeOpErrorGetAccessPointForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2091 var errorBuffer bytes.Buffer 2092 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2093 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2094 } 2095 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2096 2097 errorCode := "UnknownError" 2098 errorMessage := errorCode 2099 2100 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2101 IsWrappedWithErrorTag: true, 2102 }) 2103 if err != nil { 2104 return err 2105 } 2106 if hostID := errorComponents.HostID; len(hostID) != 0 { 2107 s3shared.SetHostIDMetadata(metadata, hostID) 2108 } 2109 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2110 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2111 } 2112 if len(errorComponents.Code) != 0 { 2113 errorCode = errorComponents.Code 2114 } 2115 if len(errorComponents.Message) != 0 { 2116 errorMessage = errorComponents.Message 2117 } 2118 errorBody.Seek(0, io.SeekStart) 2119 switch { 2120 default: 2121 genericError := &smithy.GenericAPIError{ 2122 Code: errorCode, 2123 Message: errorMessage, 2124 } 2125 return genericError 2126 2127 } 2128} 2129 2130func awsRestxml_deserializeOpDocumentGetAccessPointForObjectLambdaOutput(v **GetAccessPointForObjectLambdaOutput, decoder smithyxml.NodeDecoder) error { 2131 if v == nil { 2132 return fmt.Errorf("unexpected nil of type %T", v) 2133 } 2134 var sv *GetAccessPointForObjectLambdaOutput 2135 if *v == nil { 2136 sv = &GetAccessPointForObjectLambdaOutput{} 2137 } else { 2138 sv = *v 2139 } 2140 2141 for { 2142 t, done, err := decoder.Token() 2143 if err != nil { 2144 return err 2145 } 2146 if done { 2147 break 2148 } 2149 originalDecoder := decoder 2150 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2151 switch { 2152 case strings.EqualFold("CreationDate", t.Name.Local): 2153 val, err := decoder.Value() 2154 if err != nil { 2155 return err 2156 } 2157 if val == nil { 2158 break 2159 } 2160 { 2161 xtv := string(val) 2162 t, err := smithytime.ParseDateTime(xtv) 2163 if err != nil { 2164 return err 2165 } 2166 sv.CreationDate = ptr.Time(t) 2167 } 2168 2169 case strings.EqualFold("Name", t.Name.Local): 2170 val, err := decoder.Value() 2171 if err != nil { 2172 return err 2173 } 2174 if val == nil { 2175 break 2176 } 2177 { 2178 xtv := string(val) 2179 sv.Name = ptr.String(xtv) 2180 } 2181 2182 case strings.EqualFold("PublicAccessBlockConfiguration", t.Name.Local): 2183 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2184 if err := awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&sv.PublicAccessBlockConfiguration, nodeDecoder); err != nil { 2185 return err 2186 } 2187 2188 default: 2189 // Do nothing and ignore the unexpected tag element 2190 err = decoder.Decoder.Skip() 2191 if err != nil { 2192 return err 2193 } 2194 2195 } 2196 decoder = originalDecoder 2197 } 2198 *v = sv 2199 return nil 2200} 2201 2202type awsRestxml_deserializeOpGetAccessPointPolicy struct { 2203} 2204 2205func (*awsRestxml_deserializeOpGetAccessPointPolicy) ID() string { 2206 return "OperationDeserializer" 2207} 2208 2209func (m *awsRestxml_deserializeOpGetAccessPointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2210 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2211) { 2212 out, metadata, err = next.HandleDeserialize(ctx, in) 2213 if err != nil { 2214 return out, metadata, err 2215 } 2216 2217 response, ok := out.RawResponse.(*smithyhttp.Response) 2218 if !ok { 2219 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2220 } 2221 2222 if response.StatusCode < 200 || response.StatusCode >= 300 { 2223 return out, metadata, awsRestxml_deserializeOpErrorGetAccessPointPolicy(response, &metadata) 2224 } 2225 output := &GetAccessPointPolicyOutput{} 2226 out.Result = output 2227 2228 var buff [1024]byte 2229 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2230 body := io.TeeReader(response.Body, ringBuffer) 2231 rootDecoder := xml.NewDecoder(body) 2232 t, err := smithyxml.FetchRootElement(rootDecoder) 2233 if err == io.EOF { 2234 return out, metadata, nil 2235 } 2236 if err != nil { 2237 var snapshot bytes.Buffer 2238 io.Copy(&snapshot, ringBuffer) 2239 return out, metadata, &smithy.DeserializationError{ 2240 Err: fmt.Errorf("failed to decode response body, %w", err), 2241 Snapshot: snapshot.Bytes(), 2242 } 2243 } 2244 2245 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2246 err = awsRestxml_deserializeOpDocumentGetAccessPointPolicyOutput(&output, decoder) 2247 if err != nil { 2248 var snapshot bytes.Buffer 2249 io.Copy(&snapshot, ringBuffer) 2250 return out, metadata, &smithy.DeserializationError{ 2251 Err: fmt.Errorf("failed to decode response body, %w", err), 2252 Snapshot: snapshot.Bytes(), 2253 } 2254 } 2255 2256 return out, metadata, err 2257} 2258 2259func awsRestxml_deserializeOpErrorGetAccessPointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2260 var errorBuffer bytes.Buffer 2261 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2262 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2263 } 2264 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2265 2266 errorCode := "UnknownError" 2267 errorMessage := errorCode 2268 2269 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2270 IsWrappedWithErrorTag: true, 2271 }) 2272 if err != nil { 2273 return err 2274 } 2275 if hostID := errorComponents.HostID; len(hostID) != 0 { 2276 s3shared.SetHostIDMetadata(metadata, hostID) 2277 } 2278 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2279 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2280 } 2281 if len(errorComponents.Code) != 0 { 2282 errorCode = errorComponents.Code 2283 } 2284 if len(errorComponents.Message) != 0 { 2285 errorMessage = errorComponents.Message 2286 } 2287 errorBody.Seek(0, io.SeekStart) 2288 switch { 2289 default: 2290 genericError := &smithy.GenericAPIError{ 2291 Code: errorCode, 2292 Message: errorMessage, 2293 } 2294 return genericError 2295 2296 } 2297} 2298 2299func awsRestxml_deserializeOpDocumentGetAccessPointPolicyOutput(v **GetAccessPointPolicyOutput, decoder smithyxml.NodeDecoder) error { 2300 if v == nil { 2301 return fmt.Errorf("unexpected nil of type %T", v) 2302 } 2303 var sv *GetAccessPointPolicyOutput 2304 if *v == nil { 2305 sv = &GetAccessPointPolicyOutput{} 2306 } else { 2307 sv = *v 2308 } 2309 2310 for { 2311 t, done, err := decoder.Token() 2312 if err != nil { 2313 return err 2314 } 2315 if done { 2316 break 2317 } 2318 originalDecoder := decoder 2319 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2320 switch { 2321 case strings.EqualFold("Policy", t.Name.Local): 2322 val, err := decoder.Value() 2323 if err != nil { 2324 return err 2325 } 2326 if val == nil { 2327 break 2328 } 2329 { 2330 xtv := string(val) 2331 sv.Policy = ptr.String(xtv) 2332 } 2333 2334 default: 2335 // Do nothing and ignore the unexpected tag element 2336 err = decoder.Decoder.Skip() 2337 if err != nil { 2338 return err 2339 } 2340 2341 } 2342 decoder = originalDecoder 2343 } 2344 *v = sv 2345 return nil 2346} 2347 2348type awsRestxml_deserializeOpGetAccessPointPolicyForObjectLambda struct { 2349} 2350 2351func (*awsRestxml_deserializeOpGetAccessPointPolicyForObjectLambda) ID() string { 2352 return "OperationDeserializer" 2353} 2354 2355func (m *awsRestxml_deserializeOpGetAccessPointPolicyForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2356 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2357) { 2358 out, metadata, err = next.HandleDeserialize(ctx, in) 2359 if err != nil { 2360 return out, metadata, err 2361 } 2362 2363 response, ok := out.RawResponse.(*smithyhttp.Response) 2364 if !ok { 2365 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2366 } 2367 2368 if response.StatusCode < 200 || response.StatusCode >= 300 { 2369 return out, metadata, awsRestxml_deserializeOpErrorGetAccessPointPolicyForObjectLambda(response, &metadata) 2370 } 2371 output := &GetAccessPointPolicyForObjectLambdaOutput{} 2372 out.Result = output 2373 2374 var buff [1024]byte 2375 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2376 body := io.TeeReader(response.Body, ringBuffer) 2377 rootDecoder := xml.NewDecoder(body) 2378 t, err := smithyxml.FetchRootElement(rootDecoder) 2379 if err == io.EOF { 2380 return out, metadata, nil 2381 } 2382 if err != nil { 2383 var snapshot bytes.Buffer 2384 io.Copy(&snapshot, ringBuffer) 2385 return out, metadata, &smithy.DeserializationError{ 2386 Err: fmt.Errorf("failed to decode response body, %w", err), 2387 Snapshot: snapshot.Bytes(), 2388 } 2389 } 2390 2391 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2392 err = awsRestxml_deserializeOpDocumentGetAccessPointPolicyForObjectLambdaOutput(&output, decoder) 2393 if err != nil { 2394 var snapshot bytes.Buffer 2395 io.Copy(&snapshot, ringBuffer) 2396 return out, metadata, &smithy.DeserializationError{ 2397 Err: fmt.Errorf("failed to decode response body, %w", err), 2398 Snapshot: snapshot.Bytes(), 2399 } 2400 } 2401 2402 return out, metadata, err 2403} 2404 2405func awsRestxml_deserializeOpErrorGetAccessPointPolicyForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2406 var errorBuffer bytes.Buffer 2407 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2408 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2409 } 2410 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2411 2412 errorCode := "UnknownError" 2413 errorMessage := errorCode 2414 2415 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2416 IsWrappedWithErrorTag: true, 2417 }) 2418 if err != nil { 2419 return err 2420 } 2421 if hostID := errorComponents.HostID; len(hostID) != 0 { 2422 s3shared.SetHostIDMetadata(metadata, hostID) 2423 } 2424 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2425 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2426 } 2427 if len(errorComponents.Code) != 0 { 2428 errorCode = errorComponents.Code 2429 } 2430 if len(errorComponents.Message) != 0 { 2431 errorMessage = errorComponents.Message 2432 } 2433 errorBody.Seek(0, io.SeekStart) 2434 switch { 2435 default: 2436 genericError := &smithy.GenericAPIError{ 2437 Code: errorCode, 2438 Message: errorMessage, 2439 } 2440 return genericError 2441 2442 } 2443} 2444 2445func awsRestxml_deserializeOpDocumentGetAccessPointPolicyForObjectLambdaOutput(v **GetAccessPointPolicyForObjectLambdaOutput, decoder smithyxml.NodeDecoder) error { 2446 if v == nil { 2447 return fmt.Errorf("unexpected nil of type %T", v) 2448 } 2449 var sv *GetAccessPointPolicyForObjectLambdaOutput 2450 if *v == nil { 2451 sv = &GetAccessPointPolicyForObjectLambdaOutput{} 2452 } else { 2453 sv = *v 2454 } 2455 2456 for { 2457 t, done, err := decoder.Token() 2458 if err != nil { 2459 return err 2460 } 2461 if done { 2462 break 2463 } 2464 originalDecoder := decoder 2465 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2466 switch { 2467 case strings.EqualFold("Policy", t.Name.Local): 2468 val, err := decoder.Value() 2469 if err != nil { 2470 return err 2471 } 2472 if val == nil { 2473 break 2474 } 2475 { 2476 xtv := string(val) 2477 sv.Policy = ptr.String(xtv) 2478 } 2479 2480 default: 2481 // Do nothing and ignore the unexpected tag element 2482 err = decoder.Decoder.Skip() 2483 if err != nil { 2484 return err 2485 } 2486 2487 } 2488 decoder = originalDecoder 2489 } 2490 *v = sv 2491 return nil 2492} 2493 2494type awsRestxml_deserializeOpGetAccessPointPolicyStatus struct { 2495} 2496 2497func (*awsRestxml_deserializeOpGetAccessPointPolicyStatus) ID() string { 2498 return "OperationDeserializer" 2499} 2500 2501func (m *awsRestxml_deserializeOpGetAccessPointPolicyStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2502 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2503) { 2504 out, metadata, err = next.HandleDeserialize(ctx, in) 2505 if err != nil { 2506 return out, metadata, err 2507 } 2508 2509 response, ok := out.RawResponse.(*smithyhttp.Response) 2510 if !ok { 2511 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2512 } 2513 2514 if response.StatusCode < 200 || response.StatusCode >= 300 { 2515 return out, metadata, awsRestxml_deserializeOpErrorGetAccessPointPolicyStatus(response, &metadata) 2516 } 2517 output := &GetAccessPointPolicyStatusOutput{} 2518 out.Result = output 2519 2520 var buff [1024]byte 2521 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2522 body := io.TeeReader(response.Body, ringBuffer) 2523 rootDecoder := xml.NewDecoder(body) 2524 t, err := smithyxml.FetchRootElement(rootDecoder) 2525 if err == io.EOF { 2526 return out, metadata, nil 2527 } 2528 if err != nil { 2529 var snapshot bytes.Buffer 2530 io.Copy(&snapshot, ringBuffer) 2531 return out, metadata, &smithy.DeserializationError{ 2532 Err: fmt.Errorf("failed to decode response body, %w", err), 2533 Snapshot: snapshot.Bytes(), 2534 } 2535 } 2536 2537 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2538 err = awsRestxml_deserializeOpDocumentGetAccessPointPolicyStatusOutput(&output, decoder) 2539 if err != nil { 2540 var snapshot bytes.Buffer 2541 io.Copy(&snapshot, ringBuffer) 2542 return out, metadata, &smithy.DeserializationError{ 2543 Err: fmt.Errorf("failed to decode response body, %w", err), 2544 Snapshot: snapshot.Bytes(), 2545 } 2546 } 2547 2548 return out, metadata, err 2549} 2550 2551func awsRestxml_deserializeOpErrorGetAccessPointPolicyStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2552 var errorBuffer bytes.Buffer 2553 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2554 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2555 } 2556 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2557 2558 errorCode := "UnknownError" 2559 errorMessage := errorCode 2560 2561 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2562 IsWrappedWithErrorTag: true, 2563 }) 2564 if err != nil { 2565 return err 2566 } 2567 if hostID := errorComponents.HostID; len(hostID) != 0 { 2568 s3shared.SetHostIDMetadata(metadata, hostID) 2569 } 2570 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2571 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2572 } 2573 if len(errorComponents.Code) != 0 { 2574 errorCode = errorComponents.Code 2575 } 2576 if len(errorComponents.Message) != 0 { 2577 errorMessage = errorComponents.Message 2578 } 2579 errorBody.Seek(0, io.SeekStart) 2580 switch { 2581 default: 2582 genericError := &smithy.GenericAPIError{ 2583 Code: errorCode, 2584 Message: errorMessage, 2585 } 2586 return genericError 2587 2588 } 2589} 2590 2591func awsRestxml_deserializeOpDocumentGetAccessPointPolicyStatusOutput(v **GetAccessPointPolicyStatusOutput, decoder smithyxml.NodeDecoder) error { 2592 if v == nil { 2593 return fmt.Errorf("unexpected nil of type %T", v) 2594 } 2595 var sv *GetAccessPointPolicyStatusOutput 2596 if *v == nil { 2597 sv = &GetAccessPointPolicyStatusOutput{} 2598 } else { 2599 sv = *v 2600 } 2601 2602 for { 2603 t, done, err := decoder.Token() 2604 if err != nil { 2605 return err 2606 } 2607 if done { 2608 break 2609 } 2610 originalDecoder := decoder 2611 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2612 switch { 2613 case strings.EqualFold("PolicyStatus", t.Name.Local): 2614 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2615 if err := awsRestxml_deserializeDocumentPolicyStatus(&sv.PolicyStatus, nodeDecoder); err != nil { 2616 return err 2617 } 2618 2619 default: 2620 // Do nothing and ignore the unexpected tag element 2621 err = decoder.Decoder.Skip() 2622 if err != nil { 2623 return err 2624 } 2625 2626 } 2627 decoder = originalDecoder 2628 } 2629 *v = sv 2630 return nil 2631} 2632 2633type awsRestxml_deserializeOpGetAccessPointPolicyStatusForObjectLambda struct { 2634} 2635 2636func (*awsRestxml_deserializeOpGetAccessPointPolicyStatusForObjectLambda) ID() string { 2637 return "OperationDeserializer" 2638} 2639 2640func (m *awsRestxml_deserializeOpGetAccessPointPolicyStatusForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2641 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2642) { 2643 out, metadata, err = next.HandleDeserialize(ctx, in) 2644 if err != nil { 2645 return out, metadata, err 2646 } 2647 2648 response, ok := out.RawResponse.(*smithyhttp.Response) 2649 if !ok { 2650 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2651 } 2652 2653 if response.StatusCode < 200 || response.StatusCode >= 300 { 2654 return out, metadata, awsRestxml_deserializeOpErrorGetAccessPointPolicyStatusForObjectLambda(response, &metadata) 2655 } 2656 output := &GetAccessPointPolicyStatusForObjectLambdaOutput{} 2657 out.Result = output 2658 2659 var buff [1024]byte 2660 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2661 body := io.TeeReader(response.Body, ringBuffer) 2662 rootDecoder := xml.NewDecoder(body) 2663 t, err := smithyxml.FetchRootElement(rootDecoder) 2664 if err == io.EOF { 2665 return out, metadata, nil 2666 } 2667 if err != nil { 2668 var snapshot bytes.Buffer 2669 io.Copy(&snapshot, ringBuffer) 2670 return out, metadata, &smithy.DeserializationError{ 2671 Err: fmt.Errorf("failed to decode response body, %w", err), 2672 Snapshot: snapshot.Bytes(), 2673 } 2674 } 2675 2676 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2677 err = awsRestxml_deserializeOpDocumentGetAccessPointPolicyStatusForObjectLambdaOutput(&output, decoder) 2678 if err != nil { 2679 var snapshot bytes.Buffer 2680 io.Copy(&snapshot, ringBuffer) 2681 return out, metadata, &smithy.DeserializationError{ 2682 Err: fmt.Errorf("failed to decode response body, %w", err), 2683 Snapshot: snapshot.Bytes(), 2684 } 2685 } 2686 2687 return out, metadata, err 2688} 2689 2690func awsRestxml_deserializeOpErrorGetAccessPointPolicyStatusForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2691 var errorBuffer bytes.Buffer 2692 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2693 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2694 } 2695 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2696 2697 errorCode := "UnknownError" 2698 errorMessage := errorCode 2699 2700 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2701 IsWrappedWithErrorTag: true, 2702 }) 2703 if err != nil { 2704 return err 2705 } 2706 if hostID := errorComponents.HostID; len(hostID) != 0 { 2707 s3shared.SetHostIDMetadata(metadata, hostID) 2708 } 2709 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2710 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2711 } 2712 if len(errorComponents.Code) != 0 { 2713 errorCode = errorComponents.Code 2714 } 2715 if len(errorComponents.Message) != 0 { 2716 errorMessage = errorComponents.Message 2717 } 2718 errorBody.Seek(0, io.SeekStart) 2719 switch { 2720 default: 2721 genericError := &smithy.GenericAPIError{ 2722 Code: errorCode, 2723 Message: errorMessage, 2724 } 2725 return genericError 2726 2727 } 2728} 2729 2730func awsRestxml_deserializeOpDocumentGetAccessPointPolicyStatusForObjectLambdaOutput(v **GetAccessPointPolicyStatusForObjectLambdaOutput, decoder smithyxml.NodeDecoder) error { 2731 if v == nil { 2732 return fmt.Errorf("unexpected nil of type %T", v) 2733 } 2734 var sv *GetAccessPointPolicyStatusForObjectLambdaOutput 2735 if *v == nil { 2736 sv = &GetAccessPointPolicyStatusForObjectLambdaOutput{} 2737 } else { 2738 sv = *v 2739 } 2740 2741 for { 2742 t, done, err := decoder.Token() 2743 if err != nil { 2744 return err 2745 } 2746 if done { 2747 break 2748 } 2749 originalDecoder := decoder 2750 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2751 switch { 2752 case strings.EqualFold("PolicyStatus", t.Name.Local): 2753 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2754 if err := awsRestxml_deserializeDocumentPolicyStatus(&sv.PolicyStatus, nodeDecoder); err != nil { 2755 return err 2756 } 2757 2758 default: 2759 // Do nothing and ignore the unexpected tag element 2760 err = decoder.Decoder.Skip() 2761 if err != nil { 2762 return err 2763 } 2764 2765 } 2766 decoder = originalDecoder 2767 } 2768 *v = sv 2769 return nil 2770} 2771 2772type awsRestxml_deserializeOpGetBucket struct { 2773} 2774 2775func (*awsRestxml_deserializeOpGetBucket) ID() string { 2776 return "OperationDeserializer" 2777} 2778 2779func (m *awsRestxml_deserializeOpGetBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2780 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2781) { 2782 out, metadata, err = next.HandleDeserialize(ctx, in) 2783 if err != nil { 2784 return out, metadata, err 2785 } 2786 2787 response, ok := out.RawResponse.(*smithyhttp.Response) 2788 if !ok { 2789 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2790 } 2791 2792 if response.StatusCode < 200 || response.StatusCode >= 300 { 2793 return out, metadata, awsRestxml_deserializeOpErrorGetBucket(response, &metadata) 2794 } 2795 output := &GetBucketOutput{} 2796 out.Result = output 2797 2798 var buff [1024]byte 2799 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2800 body := io.TeeReader(response.Body, ringBuffer) 2801 rootDecoder := xml.NewDecoder(body) 2802 t, err := smithyxml.FetchRootElement(rootDecoder) 2803 if err == io.EOF { 2804 return out, metadata, nil 2805 } 2806 if err != nil { 2807 var snapshot bytes.Buffer 2808 io.Copy(&snapshot, ringBuffer) 2809 return out, metadata, &smithy.DeserializationError{ 2810 Err: fmt.Errorf("failed to decode response body, %w", err), 2811 Snapshot: snapshot.Bytes(), 2812 } 2813 } 2814 2815 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2816 err = awsRestxml_deserializeOpDocumentGetBucketOutput(&output, decoder) 2817 if err != nil { 2818 var snapshot bytes.Buffer 2819 io.Copy(&snapshot, ringBuffer) 2820 return out, metadata, &smithy.DeserializationError{ 2821 Err: fmt.Errorf("failed to decode response body, %w", err), 2822 Snapshot: snapshot.Bytes(), 2823 } 2824 } 2825 2826 return out, metadata, err 2827} 2828 2829func awsRestxml_deserializeOpErrorGetBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2830 var errorBuffer bytes.Buffer 2831 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2832 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2833 } 2834 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2835 2836 errorCode := "UnknownError" 2837 errorMessage := errorCode 2838 2839 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2840 IsWrappedWithErrorTag: true, 2841 }) 2842 if err != nil { 2843 return err 2844 } 2845 if hostID := errorComponents.HostID; len(hostID) != 0 { 2846 s3shared.SetHostIDMetadata(metadata, hostID) 2847 } 2848 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2849 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2850 } 2851 if len(errorComponents.Code) != 0 { 2852 errorCode = errorComponents.Code 2853 } 2854 if len(errorComponents.Message) != 0 { 2855 errorMessage = errorComponents.Message 2856 } 2857 errorBody.Seek(0, io.SeekStart) 2858 switch { 2859 default: 2860 genericError := &smithy.GenericAPIError{ 2861 Code: errorCode, 2862 Message: errorMessage, 2863 } 2864 return genericError 2865 2866 } 2867} 2868 2869func awsRestxml_deserializeOpDocumentGetBucketOutput(v **GetBucketOutput, decoder smithyxml.NodeDecoder) error { 2870 if v == nil { 2871 return fmt.Errorf("unexpected nil of type %T", v) 2872 } 2873 var sv *GetBucketOutput 2874 if *v == nil { 2875 sv = &GetBucketOutput{} 2876 } else { 2877 sv = *v 2878 } 2879 2880 for { 2881 t, done, err := decoder.Token() 2882 if err != nil { 2883 return err 2884 } 2885 if done { 2886 break 2887 } 2888 originalDecoder := decoder 2889 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2890 switch { 2891 case strings.EqualFold("Bucket", t.Name.Local): 2892 val, err := decoder.Value() 2893 if err != nil { 2894 return err 2895 } 2896 if val == nil { 2897 break 2898 } 2899 { 2900 xtv := string(val) 2901 sv.Bucket = ptr.String(xtv) 2902 } 2903 2904 case strings.EqualFold("CreationDate", t.Name.Local): 2905 val, err := decoder.Value() 2906 if err != nil { 2907 return err 2908 } 2909 if val == nil { 2910 break 2911 } 2912 { 2913 xtv := string(val) 2914 t, err := smithytime.ParseDateTime(xtv) 2915 if err != nil { 2916 return err 2917 } 2918 sv.CreationDate = ptr.Time(t) 2919 } 2920 2921 case strings.EqualFold("PublicAccessBlockEnabled", t.Name.Local): 2922 val, err := decoder.Value() 2923 if err != nil { 2924 return err 2925 } 2926 if val == nil { 2927 break 2928 } 2929 { 2930 xtv, err := strconv.ParseBool(string(val)) 2931 if err != nil { 2932 return fmt.Errorf("expected PublicAccessBlockEnabled to be of type *bool, got %T instead", val) 2933 } 2934 sv.PublicAccessBlockEnabled = xtv 2935 } 2936 2937 default: 2938 // Do nothing and ignore the unexpected tag element 2939 err = decoder.Decoder.Skip() 2940 if err != nil { 2941 return err 2942 } 2943 2944 } 2945 decoder = originalDecoder 2946 } 2947 *v = sv 2948 return nil 2949} 2950 2951type awsRestxml_deserializeOpGetBucketLifecycleConfiguration struct { 2952} 2953 2954func (*awsRestxml_deserializeOpGetBucketLifecycleConfiguration) ID() string { 2955 return "OperationDeserializer" 2956} 2957 2958func (m *awsRestxml_deserializeOpGetBucketLifecycleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2959 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2960) { 2961 out, metadata, err = next.HandleDeserialize(ctx, in) 2962 if err != nil { 2963 return out, metadata, err 2964 } 2965 2966 response, ok := out.RawResponse.(*smithyhttp.Response) 2967 if !ok { 2968 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2969 } 2970 2971 if response.StatusCode < 200 || response.StatusCode >= 300 { 2972 return out, metadata, awsRestxml_deserializeOpErrorGetBucketLifecycleConfiguration(response, &metadata) 2973 } 2974 output := &GetBucketLifecycleConfigurationOutput{} 2975 out.Result = output 2976 2977 var buff [1024]byte 2978 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2979 body := io.TeeReader(response.Body, ringBuffer) 2980 rootDecoder := xml.NewDecoder(body) 2981 t, err := smithyxml.FetchRootElement(rootDecoder) 2982 if err == io.EOF { 2983 return out, metadata, nil 2984 } 2985 if err != nil { 2986 var snapshot bytes.Buffer 2987 io.Copy(&snapshot, ringBuffer) 2988 return out, metadata, &smithy.DeserializationError{ 2989 Err: fmt.Errorf("failed to decode response body, %w", err), 2990 Snapshot: snapshot.Bytes(), 2991 } 2992 } 2993 2994 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2995 err = awsRestxml_deserializeOpDocumentGetBucketLifecycleConfigurationOutput(&output, decoder) 2996 if err != nil { 2997 var snapshot bytes.Buffer 2998 io.Copy(&snapshot, ringBuffer) 2999 return out, metadata, &smithy.DeserializationError{ 3000 Err: fmt.Errorf("failed to decode response body, %w", err), 3001 Snapshot: snapshot.Bytes(), 3002 } 3003 } 3004 3005 return out, metadata, err 3006} 3007 3008func awsRestxml_deserializeOpErrorGetBucketLifecycleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3009 var errorBuffer bytes.Buffer 3010 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3011 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3012 } 3013 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3014 3015 errorCode := "UnknownError" 3016 errorMessage := errorCode 3017 3018 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3019 IsWrappedWithErrorTag: true, 3020 }) 3021 if err != nil { 3022 return err 3023 } 3024 if hostID := errorComponents.HostID; len(hostID) != 0 { 3025 s3shared.SetHostIDMetadata(metadata, hostID) 3026 } 3027 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3028 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3029 } 3030 if len(errorComponents.Code) != 0 { 3031 errorCode = errorComponents.Code 3032 } 3033 if len(errorComponents.Message) != 0 { 3034 errorMessage = errorComponents.Message 3035 } 3036 errorBody.Seek(0, io.SeekStart) 3037 switch { 3038 default: 3039 genericError := &smithy.GenericAPIError{ 3040 Code: errorCode, 3041 Message: errorMessage, 3042 } 3043 return genericError 3044 3045 } 3046} 3047 3048func awsRestxml_deserializeOpDocumentGetBucketLifecycleConfigurationOutput(v **GetBucketLifecycleConfigurationOutput, decoder smithyxml.NodeDecoder) error { 3049 if v == nil { 3050 return fmt.Errorf("unexpected nil of type %T", v) 3051 } 3052 var sv *GetBucketLifecycleConfigurationOutput 3053 if *v == nil { 3054 sv = &GetBucketLifecycleConfigurationOutput{} 3055 } else { 3056 sv = *v 3057 } 3058 3059 for { 3060 t, done, err := decoder.Token() 3061 if err != nil { 3062 return err 3063 } 3064 if done { 3065 break 3066 } 3067 originalDecoder := decoder 3068 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3069 switch { 3070 case strings.EqualFold("Rules", t.Name.Local): 3071 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3072 if err := awsRestxml_deserializeDocumentLifecycleRules(&sv.Rules, nodeDecoder); err != nil { 3073 return err 3074 } 3075 3076 default: 3077 // Do nothing and ignore the unexpected tag element 3078 err = decoder.Decoder.Skip() 3079 if err != nil { 3080 return err 3081 } 3082 3083 } 3084 decoder = originalDecoder 3085 } 3086 *v = sv 3087 return nil 3088} 3089 3090type awsRestxml_deserializeOpGetBucketPolicy struct { 3091} 3092 3093func (*awsRestxml_deserializeOpGetBucketPolicy) ID() string { 3094 return "OperationDeserializer" 3095} 3096 3097func (m *awsRestxml_deserializeOpGetBucketPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3098 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3099) { 3100 out, metadata, err = next.HandleDeserialize(ctx, in) 3101 if err != nil { 3102 return out, metadata, err 3103 } 3104 3105 response, ok := out.RawResponse.(*smithyhttp.Response) 3106 if !ok { 3107 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3108 } 3109 3110 if response.StatusCode < 200 || response.StatusCode >= 300 { 3111 return out, metadata, awsRestxml_deserializeOpErrorGetBucketPolicy(response, &metadata) 3112 } 3113 output := &GetBucketPolicyOutput{} 3114 out.Result = output 3115 3116 var buff [1024]byte 3117 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3118 body := io.TeeReader(response.Body, ringBuffer) 3119 rootDecoder := xml.NewDecoder(body) 3120 t, err := smithyxml.FetchRootElement(rootDecoder) 3121 if err == io.EOF { 3122 return out, metadata, nil 3123 } 3124 if err != nil { 3125 var snapshot bytes.Buffer 3126 io.Copy(&snapshot, ringBuffer) 3127 return out, metadata, &smithy.DeserializationError{ 3128 Err: fmt.Errorf("failed to decode response body, %w", err), 3129 Snapshot: snapshot.Bytes(), 3130 } 3131 } 3132 3133 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3134 err = awsRestxml_deserializeOpDocumentGetBucketPolicyOutput(&output, decoder) 3135 if err != nil { 3136 var snapshot bytes.Buffer 3137 io.Copy(&snapshot, ringBuffer) 3138 return out, metadata, &smithy.DeserializationError{ 3139 Err: fmt.Errorf("failed to decode response body, %w", err), 3140 Snapshot: snapshot.Bytes(), 3141 } 3142 } 3143 3144 return out, metadata, err 3145} 3146 3147func awsRestxml_deserializeOpErrorGetBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3148 var errorBuffer bytes.Buffer 3149 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3150 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3151 } 3152 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3153 3154 errorCode := "UnknownError" 3155 errorMessage := errorCode 3156 3157 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3158 IsWrappedWithErrorTag: true, 3159 }) 3160 if err != nil { 3161 return err 3162 } 3163 if hostID := errorComponents.HostID; len(hostID) != 0 { 3164 s3shared.SetHostIDMetadata(metadata, hostID) 3165 } 3166 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3167 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3168 } 3169 if len(errorComponents.Code) != 0 { 3170 errorCode = errorComponents.Code 3171 } 3172 if len(errorComponents.Message) != 0 { 3173 errorMessage = errorComponents.Message 3174 } 3175 errorBody.Seek(0, io.SeekStart) 3176 switch { 3177 default: 3178 genericError := &smithy.GenericAPIError{ 3179 Code: errorCode, 3180 Message: errorMessage, 3181 } 3182 return genericError 3183 3184 } 3185} 3186 3187func awsRestxml_deserializeOpDocumentGetBucketPolicyOutput(v **GetBucketPolicyOutput, decoder smithyxml.NodeDecoder) error { 3188 if v == nil { 3189 return fmt.Errorf("unexpected nil of type %T", v) 3190 } 3191 var sv *GetBucketPolicyOutput 3192 if *v == nil { 3193 sv = &GetBucketPolicyOutput{} 3194 } else { 3195 sv = *v 3196 } 3197 3198 for { 3199 t, done, err := decoder.Token() 3200 if err != nil { 3201 return err 3202 } 3203 if done { 3204 break 3205 } 3206 originalDecoder := decoder 3207 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3208 switch { 3209 case strings.EqualFold("Policy", t.Name.Local): 3210 val, err := decoder.Value() 3211 if err != nil { 3212 return err 3213 } 3214 if val == nil { 3215 break 3216 } 3217 { 3218 xtv := string(val) 3219 sv.Policy = ptr.String(xtv) 3220 } 3221 3222 default: 3223 // Do nothing and ignore the unexpected tag element 3224 err = decoder.Decoder.Skip() 3225 if err != nil { 3226 return err 3227 } 3228 3229 } 3230 decoder = originalDecoder 3231 } 3232 *v = sv 3233 return nil 3234} 3235 3236type awsRestxml_deserializeOpGetBucketTagging struct { 3237} 3238 3239func (*awsRestxml_deserializeOpGetBucketTagging) ID() string { 3240 return "OperationDeserializer" 3241} 3242 3243func (m *awsRestxml_deserializeOpGetBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3244 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3245) { 3246 out, metadata, err = next.HandleDeserialize(ctx, in) 3247 if err != nil { 3248 return out, metadata, err 3249 } 3250 3251 response, ok := out.RawResponse.(*smithyhttp.Response) 3252 if !ok { 3253 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3254 } 3255 3256 if response.StatusCode < 200 || response.StatusCode >= 300 { 3257 return out, metadata, awsRestxml_deserializeOpErrorGetBucketTagging(response, &metadata) 3258 } 3259 output := &GetBucketTaggingOutput{} 3260 out.Result = output 3261 3262 var buff [1024]byte 3263 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3264 body := io.TeeReader(response.Body, ringBuffer) 3265 rootDecoder := xml.NewDecoder(body) 3266 t, err := smithyxml.FetchRootElement(rootDecoder) 3267 if err == io.EOF { 3268 return out, metadata, nil 3269 } 3270 if err != nil { 3271 var snapshot bytes.Buffer 3272 io.Copy(&snapshot, ringBuffer) 3273 return out, metadata, &smithy.DeserializationError{ 3274 Err: fmt.Errorf("failed to decode response body, %w", err), 3275 Snapshot: snapshot.Bytes(), 3276 } 3277 } 3278 3279 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3280 err = awsRestxml_deserializeOpDocumentGetBucketTaggingOutput(&output, decoder) 3281 if err != nil { 3282 var snapshot bytes.Buffer 3283 io.Copy(&snapshot, ringBuffer) 3284 return out, metadata, &smithy.DeserializationError{ 3285 Err: fmt.Errorf("failed to decode response body, %w", err), 3286 Snapshot: snapshot.Bytes(), 3287 } 3288 } 3289 3290 return out, metadata, err 3291} 3292 3293func awsRestxml_deserializeOpErrorGetBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3294 var errorBuffer bytes.Buffer 3295 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3296 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3297 } 3298 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3299 3300 errorCode := "UnknownError" 3301 errorMessage := errorCode 3302 3303 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3304 IsWrappedWithErrorTag: true, 3305 }) 3306 if err != nil { 3307 return err 3308 } 3309 if hostID := errorComponents.HostID; len(hostID) != 0 { 3310 s3shared.SetHostIDMetadata(metadata, hostID) 3311 } 3312 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3313 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3314 } 3315 if len(errorComponents.Code) != 0 { 3316 errorCode = errorComponents.Code 3317 } 3318 if len(errorComponents.Message) != 0 { 3319 errorMessage = errorComponents.Message 3320 } 3321 errorBody.Seek(0, io.SeekStart) 3322 switch { 3323 default: 3324 genericError := &smithy.GenericAPIError{ 3325 Code: errorCode, 3326 Message: errorMessage, 3327 } 3328 return genericError 3329 3330 } 3331} 3332 3333func awsRestxml_deserializeOpDocumentGetBucketTaggingOutput(v **GetBucketTaggingOutput, decoder smithyxml.NodeDecoder) error { 3334 if v == nil { 3335 return fmt.Errorf("unexpected nil of type %T", v) 3336 } 3337 var sv *GetBucketTaggingOutput 3338 if *v == nil { 3339 sv = &GetBucketTaggingOutput{} 3340 } else { 3341 sv = *v 3342 } 3343 3344 for { 3345 t, done, err := decoder.Token() 3346 if err != nil { 3347 return err 3348 } 3349 if done { 3350 break 3351 } 3352 originalDecoder := decoder 3353 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3354 switch { 3355 case strings.EqualFold("TagSet", t.Name.Local): 3356 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3357 if err := awsRestxml_deserializeDocumentS3TagSet(&sv.TagSet, nodeDecoder); err != nil { 3358 return err 3359 } 3360 3361 default: 3362 // Do nothing and ignore the unexpected tag element 3363 err = decoder.Decoder.Skip() 3364 if err != nil { 3365 return err 3366 } 3367 3368 } 3369 decoder = originalDecoder 3370 } 3371 *v = sv 3372 return nil 3373} 3374 3375type awsRestxml_deserializeOpGetJobTagging struct { 3376} 3377 3378func (*awsRestxml_deserializeOpGetJobTagging) ID() string { 3379 return "OperationDeserializer" 3380} 3381 3382func (m *awsRestxml_deserializeOpGetJobTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3383 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3384) { 3385 out, metadata, err = next.HandleDeserialize(ctx, in) 3386 if err != nil { 3387 return out, metadata, err 3388 } 3389 3390 response, ok := out.RawResponse.(*smithyhttp.Response) 3391 if !ok { 3392 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3393 } 3394 3395 if response.StatusCode < 200 || response.StatusCode >= 300 { 3396 return out, metadata, awsRestxml_deserializeOpErrorGetJobTagging(response, &metadata) 3397 } 3398 output := &GetJobTaggingOutput{} 3399 out.Result = output 3400 3401 var buff [1024]byte 3402 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3403 body := io.TeeReader(response.Body, ringBuffer) 3404 rootDecoder := xml.NewDecoder(body) 3405 t, err := smithyxml.FetchRootElement(rootDecoder) 3406 if err == io.EOF { 3407 return out, metadata, nil 3408 } 3409 if err != nil { 3410 var snapshot bytes.Buffer 3411 io.Copy(&snapshot, ringBuffer) 3412 return out, metadata, &smithy.DeserializationError{ 3413 Err: fmt.Errorf("failed to decode response body, %w", err), 3414 Snapshot: snapshot.Bytes(), 3415 } 3416 } 3417 3418 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3419 err = awsRestxml_deserializeOpDocumentGetJobTaggingOutput(&output, decoder) 3420 if err != nil { 3421 var snapshot bytes.Buffer 3422 io.Copy(&snapshot, ringBuffer) 3423 return out, metadata, &smithy.DeserializationError{ 3424 Err: fmt.Errorf("failed to decode response body, %w", err), 3425 Snapshot: snapshot.Bytes(), 3426 } 3427 } 3428 3429 return out, metadata, err 3430} 3431 3432func awsRestxml_deserializeOpErrorGetJobTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3433 var errorBuffer bytes.Buffer 3434 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3435 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3436 } 3437 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3438 3439 errorCode := "UnknownError" 3440 errorMessage := errorCode 3441 3442 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3443 IsWrappedWithErrorTag: true, 3444 }) 3445 if err != nil { 3446 return err 3447 } 3448 if hostID := errorComponents.HostID; len(hostID) != 0 { 3449 s3shared.SetHostIDMetadata(metadata, hostID) 3450 } 3451 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3452 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3453 } 3454 if len(errorComponents.Code) != 0 { 3455 errorCode = errorComponents.Code 3456 } 3457 if len(errorComponents.Message) != 0 { 3458 errorMessage = errorComponents.Message 3459 } 3460 errorBody.Seek(0, io.SeekStart) 3461 switch { 3462 case strings.EqualFold("InternalServiceException", errorCode): 3463 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 3464 3465 case strings.EqualFold("NotFoundException", errorCode): 3466 return awsRestxml_deserializeErrorNotFoundException(response, errorBody) 3467 3468 case strings.EqualFold("TooManyRequestsException", errorCode): 3469 return awsRestxml_deserializeErrorTooManyRequestsException(response, errorBody) 3470 3471 default: 3472 genericError := &smithy.GenericAPIError{ 3473 Code: errorCode, 3474 Message: errorMessage, 3475 } 3476 return genericError 3477 3478 } 3479} 3480 3481func awsRestxml_deserializeOpDocumentGetJobTaggingOutput(v **GetJobTaggingOutput, decoder smithyxml.NodeDecoder) error { 3482 if v == nil { 3483 return fmt.Errorf("unexpected nil of type %T", v) 3484 } 3485 var sv *GetJobTaggingOutput 3486 if *v == nil { 3487 sv = &GetJobTaggingOutput{} 3488 } else { 3489 sv = *v 3490 } 3491 3492 for { 3493 t, done, err := decoder.Token() 3494 if err != nil { 3495 return err 3496 } 3497 if done { 3498 break 3499 } 3500 originalDecoder := decoder 3501 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3502 switch { 3503 case strings.EqualFold("Tags", t.Name.Local): 3504 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3505 if err := awsRestxml_deserializeDocumentS3TagSet(&sv.Tags, nodeDecoder); err != nil { 3506 return err 3507 } 3508 3509 default: 3510 // Do nothing and ignore the unexpected tag element 3511 err = decoder.Decoder.Skip() 3512 if err != nil { 3513 return err 3514 } 3515 3516 } 3517 decoder = originalDecoder 3518 } 3519 *v = sv 3520 return nil 3521} 3522 3523type awsRestxml_deserializeOpGetPublicAccessBlock struct { 3524} 3525 3526func (*awsRestxml_deserializeOpGetPublicAccessBlock) ID() string { 3527 return "OperationDeserializer" 3528} 3529 3530func (m *awsRestxml_deserializeOpGetPublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3531 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3532) { 3533 out, metadata, err = next.HandleDeserialize(ctx, in) 3534 if err != nil { 3535 return out, metadata, err 3536 } 3537 3538 response, ok := out.RawResponse.(*smithyhttp.Response) 3539 if !ok { 3540 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3541 } 3542 3543 if response.StatusCode < 200 || response.StatusCode >= 300 { 3544 return out, metadata, awsRestxml_deserializeOpErrorGetPublicAccessBlock(response, &metadata) 3545 } 3546 output := &GetPublicAccessBlockOutput{} 3547 out.Result = output 3548 3549 var buff [1024]byte 3550 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3551 body := io.TeeReader(response.Body, ringBuffer) 3552 rootDecoder := xml.NewDecoder(body) 3553 t, err := smithyxml.FetchRootElement(rootDecoder) 3554 if err == io.EOF { 3555 return out, metadata, nil 3556 } 3557 if err != nil { 3558 var snapshot bytes.Buffer 3559 io.Copy(&snapshot, ringBuffer) 3560 return out, metadata, &smithy.DeserializationError{ 3561 Err: fmt.Errorf("failed to decode response body, %w", err), 3562 Snapshot: snapshot.Bytes(), 3563 } 3564 } 3565 3566 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3567 err = awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&output.PublicAccessBlockConfiguration, decoder) 3568 if err != nil { 3569 var snapshot bytes.Buffer 3570 io.Copy(&snapshot, ringBuffer) 3571 return out, metadata, &smithy.DeserializationError{ 3572 Err: fmt.Errorf("failed to decode response body, %w", err), 3573 Snapshot: snapshot.Bytes(), 3574 } 3575 } 3576 3577 return out, metadata, err 3578} 3579 3580func awsRestxml_deserializeOpErrorGetPublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3581 var errorBuffer bytes.Buffer 3582 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3583 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3584 } 3585 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3586 3587 errorCode := "UnknownError" 3588 errorMessage := errorCode 3589 3590 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3591 IsWrappedWithErrorTag: true, 3592 }) 3593 if err != nil { 3594 return err 3595 } 3596 if hostID := errorComponents.HostID; len(hostID) != 0 { 3597 s3shared.SetHostIDMetadata(metadata, hostID) 3598 } 3599 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3600 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3601 } 3602 if len(errorComponents.Code) != 0 { 3603 errorCode = errorComponents.Code 3604 } 3605 if len(errorComponents.Message) != 0 { 3606 errorMessage = errorComponents.Message 3607 } 3608 errorBody.Seek(0, io.SeekStart) 3609 switch { 3610 case strings.EqualFold("NoSuchPublicAccessBlockConfiguration", errorCode): 3611 return awsRestxml_deserializeErrorNoSuchPublicAccessBlockConfiguration(response, errorBody) 3612 3613 default: 3614 genericError := &smithy.GenericAPIError{ 3615 Code: errorCode, 3616 Message: errorMessage, 3617 } 3618 return genericError 3619 3620 } 3621} 3622 3623func awsRestxml_deserializeOpDocumentGetPublicAccessBlockOutput(v **GetPublicAccessBlockOutput, decoder smithyxml.NodeDecoder) error { 3624 if v == nil { 3625 return fmt.Errorf("unexpected nil of type %T", v) 3626 } 3627 var sv *GetPublicAccessBlockOutput 3628 if *v == nil { 3629 sv = &GetPublicAccessBlockOutput{} 3630 } else { 3631 sv = *v 3632 } 3633 3634 for { 3635 t, done, err := decoder.Token() 3636 if err != nil { 3637 return err 3638 } 3639 if done { 3640 break 3641 } 3642 originalDecoder := decoder 3643 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3644 switch { 3645 case strings.EqualFold("PublicAccessBlockConfiguration", t.Name.Local): 3646 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3647 if err := awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&sv.PublicAccessBlockConfiguration, nodeDecoder); err != nil { 3648 return err 3649 } 3650 3651 default: 3652 // Do nothing and ignore the unexpected tag element 3653 err = decoder.Decoder.Skip() 3654 if err != nil { 3655 return err 3656 } 3657 3658 } 3659 decoder = originalDecoder 3660 } 3661 *v = sv 3662 return nil 3663} 3664 3665type awsRestxml_deserializeOpGetStorageLensConfiguration struct { 3666} 3667 3668func (*awsRestxml_deserializeOpGetStorageLensConfiguration) ID() string { 3669 return "OperationDeserializer" 3670} 3671 3672func (m *awsRestxml_deserializeOpGetStorageLensConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3673 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3674) { 3675 out, metadata, err = next.HandleDeserialize(ctx, in) 3676 if err != nil { 3677 return out, metadata, err 3678 } 3679 3680 response, ok := out.RawResponse.(*smithyhttp.Response) 3681 if !ok { 3682 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3683 } 3684 3685 if response.StatusCode < 200 || response.StatusCode >= 300 { 3686 return out, metadata, awsRestxml_deserializeOpErrorGetStorageLensConfiguration(response, &metadata) 3687 } 3688 output := &GetStorageLensConfigurationOutput{} 3689 out.Result = output 3690 3691 var buff [1024]byte 3692 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3693 body := io.TeeReader(response.Body, ringBuffer) 3694 rootDecoder := xml.NewDecoder(body) 3695 t, err := smithyxml.FetchRootElement(rootDecoder) 3696 if err == io.EOF { 3697 return out, metadata, nil 3698 } 3699 if err != nil { 3700 var snapshot bytes.Buffer 3701 io.Copy(&snapshot, ringBuffer) 3702 return out, metadata, &smithy.DeserializationError{ 3703 Err: fmt.Errorf("failed to decode response body, %w", err), 3704 Snapshot: snapshot.Bytes(), 3705 } 3706 } 3707 3708 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3709 err = awsRestxml_deserializeDocumentStorageLensConfiguration(&output.StorageLensConfiguration, decoder) 3710 if err != nil { 3711 var snapshot bytes.Buffer 3712 io.Copy(&snapshot, ringBuffer) 3713 return out, metadata, &smithy.DeserializationError{ 3714 Err: fmt.Errorf("failed to decode response body, %w", err), 3715 Snapshot: snapshot.Bytes(), 3716 } 3717 } 3718 3719 return out, metadata, err 3720} 3721 3722func awsRestxml_deserializeOpErrorGetStorageLensConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3723 var errorBuffer bytes.Buffer 3724 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3725 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3726 } 3727 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3728 3729 errorCode := "UnknownError" 3730 errorMessage := errorCode 3731 3732 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3733 IsWrappedWithErrorTag: true, 3734 }) 3735 if err != nil { 3736 return err 3737 } 3738 if hostID := errorComponents.HostID; len(hostID) != 0 { 3739 s3shared.SetHostIDMetadata(metadata, hostID) 3740 } 3741 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3742 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3743 } 3744 if len(errorComponents.Code) != 0 { 3745 errorCode = errorComponents.Code 3746 } 3747 if len(errorComponents.Message) != 0 { 3748 errorMessage = errorComponents.Message 3749 } 3750 errorBody.Seek(0, io.SeekStart) 3751 switch { 3752 default: 3753 genericError := &smithy.GenericAPIError{ 3754 Code: errorCode, 3755 Message: errorMessage, 3756 } 3757 return genericError 3758 3759 } 3760} 3761 3762func awsRestxml_deserializeOpDocumentGetStorageLensConfigurationOutput(v **GetStorageLensConfigurationOutput, decoder smithyxml.NodeDecoder) error { 3763 if v == nil { 3764 return fmt.Errorf("unexpected nil of type %T", v) 3765 } 3766 var sv *GetStorageLensConfigurationOutput 3767 if *v == nil { 3768 sv = &GetStorageLensConfigurationOutput{} 3769 } else { 3770 sv = *v 3771 } 3772 3773 for { 3774 t, done, err := decoder.Token() 3775 if err != nil { 3776 return err 3777 } 3778 if done { 3779 break 3780 } 3781 originalDecoder := decoder 3782 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3783 switch { 3784 case strings.EqualFold("StorageLensConfiguration", t.Name.Local): 3785 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3786 if err := awsRestxml_deserializeDocumentStorageLensConfiguration(&sv.StorageLensConfiguration, nodeDecoder); err != nil { 3787 return err 3788 } 3789 3790 default: 3791 // Do nothing and ignore the unexpected tag element 3792 err = decoder.Decoder.Skip() 3793 if err != nil { 3794 return err 3795 } 3796 3797 } 3798 decoder = originalDecoder 3799 } 3800 *v = sv 3801 return nil 3802} 3803 3804type awsRestxml_deserializeOpGetStorageLensConfigurationTagging struct { 3805} 3806 3807func (*awsRestxml_deserializeOpGetStorageLensConfigurationTagging) ID() string { 3808 return "OperationDeserializer" 3809} 3810 3811func (m *awsRestxml_deserializeOpGetStorageLensConfigurationTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3812 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3813) { 3814 out, metadata, err = next.HandleDeserialize(ctx, in) 3815 if err != nil { 3816 return out, metadata, err 3817 } 3818 3819 response, ok := out.RawResponse.(*smithyhttp.Response) 3820 if !ok { 3821 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3822 } 3823 3824 if response.StatusCode < 200 || response.StatusCode >= 300 { 3825 return out, metadata, awsRestxml_deserializeOpErrorGetStorageLensConfigurationTagging(response, &metadata) 3826 } 3827 output := &GetStorageLensConfigurationTaggingOutput{} 3828 out.Result = output 3829 3830 var buff [1024]byte 3831 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3832 body := io.TeeReader(response.Body, ringBuffer) 3833 rootDecoder := xml.NewDecoder(body) 3834 t, err := smithyxml.FetchRootElement(rootDecoder) 3835 if err == io.EOF { 3836 return out, metadata, nil 3837 } 3838 if err != nil { 3839 var snapshot bytes.Buffer 3840 io.Copy(&snapshot, ringBuffer) 3841 return out, metadata, &smithy.DeserializationError{ 3842 Err: fmt.Errorf("failed to decode response body, %w", err), 3843 Snapshot: snapshot.Bytes(), 3844 } 3845 } 3846 3847 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3848 err = awsRestxml_deserializeOpDocumentGetStorageLensConfigurationTaggingOutput(&output, decoder) 3849 if err != nil { 3850 var snapshot bytes.Buffer 3851 io.Copy(&snapshot, ringBuffer) 3852 return out, metadata, &smithy.DeserializationError{ 3853 Err: fmt.Errorf("failed to decode response body, %w", err), 3854 Snapshot: snapshot.Bytes(), 3855 } 3856 } 3857 3858 return out, metadata, err 3859} 3860 3861func awsRestxml_deserializeOpErrorGetStorageLensConfigurationTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3862 var errorBuffer bytes.Buffer 3863 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3864 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3865 } 3866 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3867 3868 errorCode := "UnknownError" 3869 errorMessage := errorCode 3870 3871 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3872 IsWrappedWithErrorTag: true, 3873 }) 3874 if err != nil { 3875 return err 3876 } 3877 if hostID := errorComponents.HostID; len(hostID) != 0 { 3878 s3shared.SetHostIDMetadata(metadata, hostID) 3879 } 3880 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3881 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3882 } 3883 if len(errorComponents.Code) != 0 { 3884 errorCode = errorComponents.Code 3885 } 3886 if len(errorComponents.Message) != 0 { 3887 errorMessage = errorComponents.Message 3888 } 3889 errorBody.Seek(0, io.SeekStart) 3890 switch { 3891 default: 3892 genericError := &smithy.GenericAPIError{ 3893 Code: errorCode, 3894 Message: errorMessage, 3895 } 3896 return genericError 3897 3898 } 3899} 3900 3901func awsRestxml_deserializeOpDocumentGetStorageLensConfigurationTaggingOutput(v **GetStorageLensConfigurationTaggingOutput, decoder smithyxml.NodeDecoder) error { 3902 if v == nil { 3903 return fmt.Errorf("unexpected nil of type %T", v) 3904 } 3905 var sv *GetStorageLensConfigurationTaggingOutput 3906 if *v == nil { 3907 sv = &GetStorageLensConfigurationTaggingOutput{} 3908 } else { 3909 sv = *v 3910 } 3911 3912 for { 3913 t, done, err := decoder.Token() 3914 if err != nil { 3915 return err 3916 } 3917 if done { 3918 break 3919 } 3920 originalDecoder := decoder 3921 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3922 switch { 3923 case strings.EqualFold("Tags", t.Name.Local): 3924 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3925 if err := awsRestxml_deserializeDocumentStorageLensTags(&sv.Tags, nodeDecoder); err != nil { 3926 return err 3927 } 3928 3929 default: 3930 // Do nothing and ignore the unexpected tag element 3931 err = decoder.Decoder.Skip() 3932 if err != nil { 3933 return err 3934 } 3935 3936 } 3937 decoder = originalDecoder 3938 } 3939 *v = sv 3940 return nil 3941} 3942 3943type awsRestxml_deserializeOpListAccessPoints struct { 3944} 3945 3946func (*awsRestxml_deserializeOpListAccessPoints) ID() string { 3947 return "OperationDeserializer" 3948} 3949 3950func (m *awsRestxml_deserializeOpListAccessPoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3951 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3952) { 3953 out, metadata, err = next.HandleDeserialize(ctx, in) 3954 if err != nil { 3955 return out, metadata, err 3956 } 3957 3958 response, ok := out.RawResponse.(*smithyhttp.Response) 3959 if !ok { 3960 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3961 } 3962 3963 if response.StatusCode < 200 || response.StatusCode >= 300 { 3964 return out, metadata, awsRestxml_deserializeOpErrorListAccessPoints(response, &metadata) 3965 } 3966 output := &ListAccessPointsOutput{} 3967 out.Result = output 3968 3969 var buff [1024]byte 3970 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3971 body := io.TeeReader(response.Body, ringBuffer) 3972 rootDecoder := xml.NewDecoder(body) 3973 t, err := smithyxml.FetchRootElement(rootDecoder) 3974 if err == io.EOF { 3975 return out, metadata, nil 3976 } 3977 if err != nil { 3978 var snapshot bytes.Buffer 3979 io.Copy(&snapshot, ringBuffer) 3980 return out, metadata, &smithy.DeserializationError{ 3981 Err: fmt.Errorf("failed to decode response body, %w", err), 3982 Snapshot: snapshot.Bytes(), 3983 } 3984 } 3985 3986 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3987 err = awsRestxml_deserializeOpDocumentListAccessPointsOutput(&output, decoder) 3988 if err != nil { 3989 var snapshot bytes.Buffer 3990 io.Copy(&snapshot, ringBuffer) 3991 return out, metadata, &smithy.DeserializationError{ 3992 Err: fmt.Errorf("failed to decode response body, %w", err), 3993 Snapshot: snapshot.Bytes(), 3994 } 3995 } 3996 3997 return out, metadata, err 3998} 3999 4000func awsRestxml_deserializeOpErrorListAccessPoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4001 var errorBuffer bytes.Buffer 4002 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4003 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4004 } 4005 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4006 4007 errorCode := "UnknownError" 4008 errorMessage := errorCode 4009 4010 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4011 IsWrappedWithErrorTag: true, 4012 }) 4013 if err != nil { 4014 return err 4015 } 4016 if hostID := errorComponents.HostID; len(hostID) != 0 { 4017 s3shared.SetHostIDMetadata(metadata, hostID) 4018 } 4019 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4020 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4021 } 4022 if len(errorComponents.Code) != 0 { 4023 errorCode = errorComponents.Code 4024 } 4025 if len(errorComponents.Message) != 0 { 4026 errorMessage = errorComponents.Message 4027 } 4028 errorBody.Seek(0, io.SeekStart) 4029 switch { 4030 default: 4031 genericError := &smithy.GenericAPIError{ 4032 Code: errorCode, 4033 Message: errorMessage, 4034 } 4035 return genericError 4036 4037 } 4038} 4039 4040func awsRestxml_deserializeOpDocumentListAccessPointsOutput(v **ListAccessPointsOutput, decoder smithyxml.NodeDecoder) error { 4041 if v == nil { 4042 return fmt.Errorf("unexpected nil of type %T", v) 4043 } 4044 var sv *ListAccessPointsOutput 4045 if *v == nil { 4046 sv = &ListAccessPointsOutput{} 4047 } else { 4048 sv = *v 4049 } 4050 4051 for { 4052 t, done, err := decoder.Token() 4053 if err != nil { 4054 return err 4055 } 4056 if done { 4057 break 4058 } 4059 originalDecoder := decoder 4060 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4061 switch { 4062 case strings.EqualFold("AccessPointList", t.Name.Local): 4063 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4064 if err := awsRestxml_deserializeDocumentAccessPointList(&sv.AccessPointList, nodeDecoder); err != nil { 4065 return err 4066 } 4067 4068 case strings.EqualFold("NextToken", t.Name.Local): 4069 val, err := decoder.Value() 4070 if err != nil { 4071 return err 4072 } 4073 if val == nil { 4074 break 4075 } 4076 { 4077 xtv := string(val) 4078 sv.NextToken = ptr.String(xtv) 4079 } 4080 4081 default: 4082 // Do nothing and ignore the unexpected tag element 4083 err = decoder.Decoder.Skip() 4084 if err != nil { 4085 return err 4086 } 4087 4088 } 4089 decoder = originalDecoder 4090 } 4091 *v = sv 4092 return nil 4093} 4094 4095type awsRestxml_deserializeOpListAccessPointsForObjectLambda struct { 4096} 4097 4098func (*awsRestxml_deserializeOpListAccessPointsForObjectLambda) ID() string { 4099 return "OperationDeserializer" 4100} 4101 4102func (m *awsRestxml_deserializeOpListAccessPointsForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4103 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4104) { 4105 out, metadata, err = next.HandleDeserialize(ctx, in) 4106 if err != nil { 4107 return out, metadata, err 4108 } 4109 4110 response, ok := out.RawResponse.(*smithyhttp.Response) 4111 if !ok { 4112 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4113 } 4114 4115 if response.StatusCode < 200 || response.StatusCode >= 300 { 4116 return out, metadata, awsRestxml_deserializeOpErrorListAccessPointsForObjectLambda(response, &metadata) 4117 } 4118 output := &ListAccessPointsForObjectLambdaOutput{} 4119 out.Result = output 4120 4121 var buff [1024]byte 4122 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4123 body := io.TeeReader(response.Body, ringBuffer) 4124 rootDecoder := xml.NewDecoder(body) 4125 t, err := smithyxml.FetchRootElement(rootDecoder) 4126 if err == io.EOF { 4127 return out, metadata, nil 4128 } 4129 if err != nil { 4130 var snapshot bytes.Buffer 4131 io.Copy(&snapshot, ringBuffer) 4132 return out, metadata, &smithy.DeserializationError{ 4133 Err: fmt.Errorf("failed to decode response body, %w", err), 4134 Snapshot: snapshot.Bytes(), 4135 } 4136 } 4137 4138 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4139 err = awsRestxml_deserializeOpDocumentListAccessPointsForObjectLambdaOutput(&output, decoder) 4140 if err != nil { 4141 var snapshot bytes.Buffer 4142 io.Copy(&snapshot, ringBuffer) 4143 return out, metadata, &smithy.DeserializationError{ 4144 Err: fmt.Errorf("failed to decode response body, %w", err), 4145 Snapshot: snapshot.Bytes(), 4146 } 4147 } 4148 4149 return out, metadata, err 4150} 4151 4152func awsRestxml_deserializeOpErrorListAccessPointsForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4153 var errorBuffer bytes.Buffer 4154 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4155 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4156 } 4157 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4158 4159 errorCode := "UnknownError" 4160 errorMessage := errorCode 4161 4162 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4163 IsWrappedWithErrorTag: true, 4164 }) 4165 if err != nil { 4166 return err 4167 } 4168 if hostID := errorComponents.HostID; len(hostID) != 0 { 4169 s3shared.SetHostIDMetadata(metadata, hostID) 4170 } 4171 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4172 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4173 } 4174 if len(errorComponents.Code) != 0 { 4175 errorCode = errorComponents.Code 4176 } 4177 if len(errorComponents.Message) != 0 { 4178 errorMessage = errorComponents.Message 4179 } 4180 errorBody.Seek(0, io.SeekStart) 4181 switch { 4182 default: 4183 genericError := &smithy.GenericAPIError{ 4184 Code: errorCode, 4185 Message: errorMessage, 4186 } 4187 return genericError 4188 4189 } 4190} 4191 4192func awsRestxml_deserializeOpDocumentListAccessPointsForObjectLambdaOutput(v **ListAccessPointsForObjectLambdaOutput, decoder smithyxml.NodeDecoder) error { 4193 if v == nil { 4194 return fmt.Errorf("unexpected nil of type %T", v) 4195 } 4196 var sv *ListAccessPointsForObjectLambdaOutput 4197 if *v == nil { 4198 sv = &ListAccessPointsForObjectLambdaOutput{} 4199 } else { 4200 sv = *v 4201 } 4202 4203 for { 4204 t, done, err := decoder.Token() 4205 if err != nil { 4206 return err 4207 } 4208 if done { 4209 break 4210 } 4211 originalDecoder := decoder 4212 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4213 switch { 4214 case strings.EqualFold("NextToken", t.Name.Local): 4215 val, err := decoder.Value() 4216 if err != nil { 4217 return err 4218 } 4219 if val == nil { 4220 break 4221 } 4222 { 4223 xtv := string(val) 4224 sv.NextToken = ptr.String(xtv) 4225 } 4226 4227 case strings.EqualFold("ObjectLambdaAccessPointList", t.Name.Local): 4228 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4229 if err := awsRestxml_deserializeDocumentObjectLambdaAccessPointList(&sv.ObjectLambdaAccessPointList, nodeDecoder); err != nil { 4230 return err 4231 } 4232 4233 default: 4234 // Do nothing and ignore the unexpected tag element 4235 err = decoder.Decoder.Skip() 4236 if err != nil { 4237 return err 4238 } 4239 4240 } 4241 decoder = originalDecoder 4242 } 4243 *v = sv 4244 return nil 4245} 4246 4247type awsRestxml_deserializeOpListJobs struct { 4248} 4249 4250func (*awsRestxml_deserializeOpListJobs) ID() string { 4251 return "OperationDeserializer" 4252} 4253 4254func (m *awsRestxml_deserializeOpListJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4255 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4256) { 4257 out, metadata, err = next.HandleDeserialize(ctx, in) 4258 if err != nil { 4259 return out, metadata, err 4260 } 4261 4262 response, ok := out.RawResponse.(*smithyhttp.Response) 4263 if !ok { 4264 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4265 } 4266 4267 if response.StatusCode < 200 || response.StatusCode >= 300 { 4268 return out, metadata, awsRestxml_deserializeOpErrorListJobs(response, &metadata) 4269 } 4270 output := &ListJobsOutput{} 4271 out.Result = output 4272 4273 var buff [1024]byte 4274 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4275 body := io.TeeReader(response.Body, ringBuffer) 4276 rootDecoder := xml.NewDecoder(body) 4277 t, err := smithyxml.FetchRootElement(rootDecoder) 4278 if err == io.EOF { 4279 return out, metadata, nil 4280 } 4281 if err != nil { 4282 var snapshot bytes.Buffer 4283 io.Copy(&snapshot, ringBuffer) 4284 return out, metadata, &smithy.DeserializationError{ 4285 Err: fmt.Errorf("failed to decode response body, %w", err), 4286 Snapshot: snapshot.Bytes(), 4287 } 4288 } 4289 4290 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4291 err = awsRestxml_deserializeOpDocumentListJobsOutput(&output, decoder) 4292 if err != nil { 4293 var snapshot bytes.Buffer 4294 io.Copy(&snapshot, ringBuffer) 4295 return out, metadata, &smithy.DeserializationError{ 4296 Err: fmt.Errorf("failed to decode response body, %w", err), 4297 Snapshot: snapshot.Bytes(), 4298 } 4299 } 4300 4301 return out, metadata, err 4302} 4303 4304func awsRestxml_deserializeOpErrorListJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4305 var errorBuffer bytes.Buffer 4306 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4307 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4308 } 4309 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4310 4311 errorCode := "UnknownError" 4312 errorMessage := errorCode 4313 4314 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4315 IsWrappedWithErrorTag: true, 4316 }) 4317 if err != nil { 4318 return err 4319 } 4320 if hostID := errorComponents.HostID; len(hostID) != 0 { 4321 s3shared.SetHostIDMetadata(metadata, hostID) 4322 } 4323 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4324 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4325 } 4326 if len(errorComponents.Code) != 0 { 4327 errorCode = errorComponents.Code 4328 } 4329 if len(errorComponents.Message) != 0 { 4330 errorMessage = errorComponents.Message 4331 } 4332 errorBody.Seek(0, io.SeekStart) 4333 switch { 4334 case strings.EqualFold("InternalServiceException", errorCode): 4335 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 4336 4337 case strings.EqualFold("InvalidNextTokenException", errorCode): 4338 return awsRestxml_deserializeErrorInvalidNextTokenException(response, errorBody) 4339 4340 case strings.EqualFold("InvalidRequestException", errorCode): 4341 return awsRestxml_deserializeErrorInvalidRequestException(response, errorBody) 4342 4343 default: 4344 genericError := &smithy.GenericAPIError{ 4345 Code: errorCode, 4346 Message: errorMessage, 4347 } 4348 return genericError 4349 4350 } 4351} 4352 4353func awsRestxml_deserializeOpDocumentListJobsOutput(v **ListJobsOutput, decoder smithyxml.NodeDecoder) error { 4354 if v == nil { 4355 return fmt.Errorf("unexpected nil of type %T", v) 4356 } 4357 var sv *ListJobsOutput 4358 if *v == nil { 4359 sv = &ListJobsOutput{} 4360 } else { 4361 sv = *v 4362 } 4363 4364 for { 4365 t, done, err := decoder.Token() 4366 if err != nil { 4367 return err 4368 } 4369 if done { 4370 break 4371 } 4372 originalDecoder := decoder 4373 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4374 switch { 4375 case strings.EqualFold("Jobs", t.Name.Local): 4376 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4377 if err := awsRestxml_deserializeDocumentJobListDescriptorList(&sv.Jobs, nodeDecoder); err != nil { 4378 return err 4379 } 4380 4381 case strings.EqualFold("NextToken", t.Name.Local): 4382 val, err := decoder.Value() 4383 if err != nil { 4384 return err 4385 } 4386 if val == nil { 4387 break 4388 } 4389 { 4390 xtv := string(val) 4391 sv.NextToken = ptr.String(xtv) 4392 } 4393 4394 default: 4395 // Do nothing and ignore the unexpected tag element 4396 err = decoder.Decoder.Skip() 4397 if err != nil { 4398 return err 4399 } 4400 4401 } 4402 decoder = originalDecoder 4403 } 4404 *v = sv 4405 return nil 4406} 4407 4408type awsRestxml_deserializeOpListRegionalBuckets struct { 4409} 4410 4411func (*awsRestxml_deserializeOpListRegionalBuckets) ID() string { 4412 return "OperationDeserializer" 4413} 4414 4415func (m *awsRestxml_deserializeOpListRegionalBuckets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4416 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4417) { 4418 out, metadata, err = next.HandleDeserialize(ctx, in) 4419 if err != nil { 4420 return out, metadata, err 4421 } 4422 4423 response, ok := out.RawResponse.(*smithyhttp.Response) 4424 if !ok { 4425 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4426 } 4427 4428 if response.StatusCode < 200 || response.StatusCode >= 300 { 4429 return out, metadata, awsRestxml_deserializeOpErrorListRegionalBuckets(response, &metadata) 4430 } 4431 output := &ListRegionalBucketsOutput{} 4432 out.Result = output 4433 4434 var buff [1024]byte 4435 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4436 body := io.TeeReader(response.Body, ringBuffer) 4437 rootDecoder := xml.NewDecoder(body) 4438 t, err := smithyxml.FetchRootElement(rootDecoder) 4439 if err == io.EOF { 4440 return out, metadata, nil 4441 } 4442 if err != nil { 4443 var snapshot bytes.Buffer 4444 io.Copy(&snapshot, ringBuffer) 4445 return out, metadata, &smithy.DeserializationError{ 4446 Err: fmt.Errorf("failed to decode response body, %w", err), 4447 Snapshot: snapshot.Bytes(), 4448 } 4449 } 4450 4451 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4452 err = awsRestxml_deserializeOpDocumentListRegionalBucketsOutput(&output, decoder) 4453 if err != nil { 4454 var snapshot bytes.Buffer 4455 io.Copy(&snapshot, ringBuffer) 4456 return out, metadata, &smithy.DeserializationError{ 4457 Err: fmt.Errorf("failed to decode response body, %w", err), 4458 Snapshot: snapshot.Bytes(), 4459 } 4460 } 4461 4462 return out, metadata, err 4463} 4464 4465func awsRestxml_deserializeOpErrorListRegionalBuckets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4466 var errorBuffer bytes.Buffer 4467 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4468 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4469 } 4470 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4471 4472 errorCode := "UnknownError" 4473 errorMessage := errorCode 4474 4475 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4476 IsWrappedWithErrorTag: true, 4477 }) 4478 if err != nil { 4479 return err 4480 } 4481 if hostID := errorComponents.HostID; len(hostID) != 0 { 4482 s3shared.SetHostIDMetadata(metadata, hostID) 4483 } 4484 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4485 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4486 } 4487 if len(errorComponents.Code) != 0 { 4488 errorCode = errorComponents.Code 4489 } 4490 if len(errorComponents.Message) != 0 { 4491 errorMessage = errorComponents.Message 4492 } 4493 errorBody.Seek(0, io.SeekStart) 4494 switch { 4495 default: 4496 genericError := &smithy.GenericAPIError{ 4497 Code: errorCode, 4498 Message: errorMessage, 4499 } 4500 return genericError 4501 4502 } 4503} 4504 4505func awsRestxml_deserializeOpDocumentListRegionalBucketsOutput(v **ListRegionalBucketsOutput, decoder smithyxml.NodeDecoder) error { 4506 if v == nil { 4507 return fmt.Errorf("unexpected nil of type %T", v) 4508 } 4509 var sv *ListRegionalBucketsOutput 4510 if *v == nil { 4511 sv = &ListRegionalBucketsOutput{} 4512 } else { 4513 sv = *v 4514 } 4515 4516 for { 4517 t, done, err := decoder.Token() 4518 if err != nil { 4519 return err 4520 } 4521 if done { 4522 break 4523 } 4524 originalDecoder := decoder 4525 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4526 switch { 4527 case strings.EqualFold("NextToken", t.Name.Local): 4528 val, err := decoder.Value() 4529 if err != nil { 4530 return err 4531 } 4532 if val == nil { 4533 break 4534 } 4535 { 4536 xtv := string(val) 4537 sv.NextToken = ptr.String(xtv) 4538 } 4539 4540 case strings.EqualFold("RegionalBucketList", t.Name.Local): 4541 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4542 if err := awsRestxml_deserializeDocumentRegionalBucketList(&sv.RegionalBucketList, nodeDecoder); err != nil { 4543 return err 4544 } 4545 4546 default: 4547 // Do nothing and ignore the unexpected tag element 4548 err = decoder.Decoder.Skip() 4549 if err != nil { 4550 return err 4551 } 4552 4553 } 4554 decoder = originalDecoder 4555 } 4556 *v = sv 4557 return nil 4558} 4559 4560type awsRestxml_deserializeOpListStorageLensConfigurations struct { 4561} 4562 4563func (*awsRestxml_deserializeOpListStorageLensConfigurations) ID() string { 4564 return "OperationDeserializer" 4565} 4566 4567func (m *awsRestxml_deserializeOpListStorageLensConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4568 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4569) { 4570 out, metadata, err = next.HandleDeserialize(ctx, in) 4571 if err != nil { 4572 return out, metadata, err 4573 } 4574 4575 response, ok := out.RawResponse.(*smithyhttp.Response) 4576 if !ok { 4577 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4578 } 4579 4580 if response.StatusCode < 200 || response.StatusCode >= 300 { 4581 return out, metadata, awsRestxml_deserializeOpErrorListStorageLensConfigurations(response, &metadata) 4582 } 4583 output := &ListStorageLensConfigurationsOutput{} 4584 out.Result = output 4585 4586 var buff [1024]byte 4587 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4588 body := io.TeeReader(response.Body, ringBuffer) 4589 rootDecoder := xml.NewDecoder(body) 4590 t, err := smithyxml.FetchRootElement(rootDecoder) 4591 if err == io.EOF { 4592 return out, metadata, nil 4593 } 4594 if err != nil { 4595 var snapshot bytes.Buffer 4596 io.Copy(&snapshot, ringBuffer) 4597 return out, metadata, &smithy.DeserializationError{ 4598 Err: fmt.Errorf("failed to decode response body, %w", err), 4599 Snapshot: snapshot.Bytes(), 4600 } 4601 } 4602 4603 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4604 err = awsRestxml_deserializeOpDocumentListStorageLensConfigurationsOutput(&output, decoder) 4605 if err != nil { 4606 var snapshot bytes.Buffer 4607 io.Copy(&snapshot, ringBuffer) 4608 return out, metadata, &smithy.DeserializationError{ 4609 Err: fmt.Errorf("failed to decode response body, %w", err), 4610 Snapshot: snapshot.Bytes(), 4611 } 4612 } 4613 4614 return out, metadata, err 4615} 4616 4617func awsRestxml_deserializeOpErrorListStorageLensConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4618 var errorBuffer bytes.Buffer 4619 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4620 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4621 } 4622 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4623 4624 errorCode := "UnknownError" 4625 errorMessage := errorCode 4626 4627 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4628 IsWrappedWithErrorTag: true, 4629 }) 4630 if err != nil { 4631 return err 4632 } 4633 if hostID := errorComponents.HostID; len(hostID) != 0 { 4634 s3shared.SetHostIDMetadata(metadata, hostID) 4635 } 4636 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4637 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4638 } 4639 if len(errorComponents.Code) != 0 { 4640 errorCode = errorComponents.Code 4641 } 4642 if len(errorComponents.Message) != 0 { 4643 errorMessage = errorComponents.Message 4644 } 4645 errorBody.Seek(0, io.SeekStart) 4646 switch { 4647 default: 4648 genericError := &smithy.GenericAPIError{ 4649 Code: errorCode, 4650 Message: errorMessage, 4651 } 4652 return genericError 4653 4654 } 4655} 4656 4657func awsRestxml_deserializeOpDocumentListStorageLensConfigurationsOutput(v **ListStorageLensConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 4658 if v == nil { 4659 return fmt.Errorf("unexpected nil of type %T", v) 4660 } 4661 var sv *ListStorageLensConfigurationsOutput 4662 if *v == nil { 4663 sv = &ListStorageLensConfigurationsOutput{} 4664 } else { 4665 sv = *v 4666 } 4667 4668 for { 4669 t, done, err := decoder.Token() 4670 if err != nil { 4671 return err 4672 } 4673 if done { 4674 break 4675 } 4676 originalDecoder := decoder 4677 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4678 switch { 4679 case strings.EqualFold("NextToken", t.Name.Local): 4680 val, err := decoder.Value() 4681 if err != nil { 4682 return err 4683 } 4684 if val == nil { 4685 break 4686 } 4687 { 4688 xtv := string(val) 4689 sv.NextToken = ptr.String(xtv) 4690 } 4691 4692 case strings.EqualFold("StorageLensConfigurationList", t.Name.Local): 4693 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4694 if err := awsRestxml_deserializeDocumentStorageLensConfigurationListUnwrapped(&sv.StorageLensConfigurationList, nodeDecoder); err != nil { 4695 return err 4696 } 4697 4698 default: 4699 // Do nothing and ignore the unexpected tag element 4700 err = decoder.Decoder.Skip() 4701 if err != nil { 4702 return err 4703 } 4704 4705 } 4706 decoder = originalDecoder 4707 } 4708 *v = sv 4709 return nil 4710} 4711 4712type awsRestxml_deserializeOpPutAccessPointConfigurationForObjectLambda struct { 4713} 4714 4715func (*awsRestxml_deserializeOpPutAccessPointConfigurationForObjectLambda) ID() string { 4716 return "OperationDeserializer" 4717} 4718 4719func (m *awsRestxml_deserializeOpPutAccessPointConfigurationForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4720 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4721) { 4722 out, metadata, err = next.HandleDeserialize(ctx, in) 4723 if err != nil { 4724 return out, metadata, err 4725 } 4726 4727 response, ok := out.RawResponse.(*smithyhttp.Response) 4728 if !ok { 4729 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4730 } 4731 4732 if response.StatusCode < 200 || response.StatusCode >= 300 { 4733 return out, metadata, awsRestxml_deserializeOpErrorPutAccessPointConfigurationForObjectLambda(response, &metadata) 4734 } 4735 output := &PutAccessPointConfigurationForObjectLambdaOutput{} 4736 out.Result = output 4737 4738 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4739 return out, metadata, &smithy.DeserializationError{ 4740 Err: fmt.Errorf("failed to discard response body, %w", err), 4741 } 4742 } 4743 4744 return out, metadata, err 4745} 4746 4747func awsRestxml_deserializeOpErrorPutAccessPointConfigurationForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4748 var errorBuffer bytes.Buffer 4749 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4750 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4751 } 4752 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4753 4754 errorCode := "UnknownError" 4755 errorMessage := errorCode 4756 4757 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4758 IsWrappedWithErrorTag: true, 4759 }) 4760 if err != nil { 4761 return err 4762 } 4763 if hostID := errorComponents.HostID; len(hostID) != 0 { 4764 s3shared.SetHostIDMetadata(metadata, hostID) 4765 } 4766 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4767 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4768 } 4769 if len(errorComponents.Code) != 0 { 4770 errorCode = errorComponents.Code 4771 } 4772 if len(errorComponents.Message) != 0 { 4773 errorMessage = errorComponents.Message 4774 } 4775 errorBody.Seek(0, io.SeekStart) 4776 switch { 4777 default: 4778 genericError := &smithy.GenericAPIError{ 4779 Code: errorCode, 4780 Message: errorMessage, 4781 } 4782 return genericError 4783 4784 } 4785} 4786 4787type awsRestxml_deserializeOpPutAccessPointPolicy struct { 4788} 4789 4790func (*awsRestxml_deserializeOpPutAccessPointPolicy) ID() string { 4791 return "OperationDeserializer" 4792} 4793 4794func (m *awsRestxml_deserializeOpPutAccessPointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4795 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4796) { 4797 out, metadata, err = next.HandleDeserialize(ctx, in) 4798 if err != nil { 4799 return out, metadata, err 4800 } 4801 4802 response, ok := out.RawResponse.(*smithyhttp.Response) 4803 if !ok { 4804 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4805 } 4806 4807 if response.StatusCode < 200 || response.StatusCode >= 300 { 4808 return out, metadata, awsRestxml_deserializeOpErrorPutAccessPointPolicy(response, &metadata) 4809 } 4810 output := &PutAccessPointPolicyOutput{} 4811 out.Result = output 4812 4813 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4814 return out, metadata, &smithy.DeserializationError{ 4815 Err: fmt.Errorf("failed to discard response body, %w", err), 4816 } 4817 } 4818 4819 return out, metadata, err 4820} 4821 4822func awsRestxml_deserializeOpErrorPutAccessPointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4823 var errorBuffer bytes.Buffer 4824 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4825 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4826 } 4827 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4828 4829 errorCode := "UnknownError" 4830 errorMessage := errorCode 4831 4832 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4833 IsWrappedWithErrorTag: true, 4834 }) 4835 if err != nil { 4836 return err 4837 } 4838 if hostID := errorComponents.HostID; len(hostID) != 0 { 4839 s3shared.SetHostIDMetadata(metadata, hostID) 4840 } 4841 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4842 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4843 } 4844 if len(errorComponents.Code) != 0 { 4845 errorCode = errorComponents.Code 4846 } 4847 if len(errorComponents.Message) != 0 { 4848 errorMessage = errorComponents.Message 4849 } 4850 errorBody.Seek(0, io.SeekStart) 4851 switch { 4852 default: 4853 genericError := &smithy.GenericAPIError{ 4854 Code: errorCode, 4855 Message: errorMessage, 4856 } 4857 return genericError 4858 4859 } 4860} 4861 4862type awsRestxml_deserializeOpPutAccessPointPolicyForObjectLambda struct { 4863} 4864 4865func (*awsRestxml_deserializeOpPutAccessPointPolicyForObjectLambda) ID() string { 4866 return "OperationDeserializer" 4867} 4868 4869func (m *awsRestxml_deserializeOpPutAccessPointPolicyForObjectLambda) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4870 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4871) { 4872 out, metadata, err = next.HandleDeserialize(ctx, in) 4873 if err != nil { 4874 return out, metadata, err 4875 } 4876 4877 response, ok := out.RawResponse.(*smithyhttp.Response) 4878 if !ok { 4879 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4880 } 4881 4882 if response.StatusCode < 200 || response.StatusCode >= 300 { 4883 return out, metadata, awsRestxml_deserializeOpErrorPutAccessPointPolicyForObjectLambda(response, &metadata) 4884 } 4885 output := &PutAccessPointPolicyForObjectLambdaOutput{} 4886 out.Result = output 4887 4888 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4889 return out, metadata, &smithy.DeserializationError{ 4890 Err: fmt.Errorf("failed to discard response body, %w", err), 4891 } 4892 } 4893 4894 return out, metadata, err 4895} 4896 4897func awsRestxml_deserializeOpErrorPutAccessPointPolicyForObjectLambda(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4898 var errorBuffer bytes.Buffer 4899 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4900 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4901 } 4902 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4903 4904 errorCode := "UnknownError" 4905 errorMessage := errorCode 4906 4907 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4908 IsWrappedWithErrorTag: true, 4909 }) 4910 if err != nil { 4911 return err 4912 } 4913 if hostID := errorComponents.HostID; len(hostID) != 0 { 4914 s3shared.SetHostIDMetadata(metadata, hostID) 4915 } 4916 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4917 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4918 } 4919 if len(errorComponents.Code) != 0 { 4920 errorCode = errorComponents.Code 4921 } 4922 if len(errorComponents.Message) != 0 { 4923 errorMessage = errorComponents.Message 4924 } 4925 errorBody.Seek(0, io.SeekStart) 4926 switch { 4927 default: 4928 genericError := &smithy.GenericAPIError{ 4929 Code: errorCode, 4930 Message: errorMessage, 4931 } 4932 return genericError 4933 4934 } 4935} 4936 4937type awsRestxml_deserializeOpPutBucketLifecycleConfiguration struct { 4938} 4939 4940func (*awsRestxml_deserializeOpPutBucketLifecycleConfiguration) ID() string { 4941 return "OperationDeserializer" 4942} 4943 4944func (m *awsRestxml_deserializeOpPutBucketLifecycleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4945 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4946) { 4947 out, metadata, err = next.HandleDeserialize(ctx, in) 4948 if err != nil { 4949 return out, metadata, err 4950 } 4951 4952 response, ok := out.RawResponse.(*smithyhttp.Response) 4953 if !ok { 4954 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4955 } 4956 4957 if response.StatusCode < 200 || response.StatusCode >= 300 { 4958 return out, metadata, awsRestxml_deserializeOpErrorPutBucketLifecycleConfiguration(response, &metadata) 4959 } 4960 output := &PutBucketLifecycleConfigurationOutput{} 4961 out.Result = output 4962 4963 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4964 return out, metadata, &smithy.DeserializationError{ 4965 Err: fmt.Errorf("failed to discard response body, %w", err), 4966 } 4967 } 4968 4969 return out, metadata, err 4970} 4971 4972func awsRestxml_deserializeOpErrorPutBucketLifecycleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4973 var errorBuffer bytes.Buffer 4974 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4975 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4976 } 4977 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4978 4979 errorCode := "UnknownError" 4980 errorMessage := errorCode 4981 4982 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4983 IsWrappedWithErrorTag: true, 4984 }) 4985 if err != nil { 4986 return err 4987 } 4988 if hostID := errorComponents.HostID; len(hostID) != 0 { 4989 s3shared.SetHostIDMetadata(metadata, hostID) 4990 } 4991 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4992 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4993 } 4994 if len(errorComponents.Code) != 0 { 4995 errorCode = errorComponents.Code 4996 } 4997 if len(errorComponents.Message) != 0 { 4998 errorMessage = errorComponents.Message 4999 } 5000 errorBody.Seek(0, io.SeekStart) 5001 switch { 5002 default: 5003 genericError := &smithy.GenericAPIError{ 5004 Code: errorCode, 5005 Message: errorMessage, 5006 } 5007 return genericError 5008 5009 } 5010} 5011 5012type awsRestxml_deserializeOpPutBucketPolicy struct { 5013} 5014 5015func (*awsRestxml_deserializeOpPutBucketPolicy) ID() string { 5016 return "OperationDeserializer" 5017} 5018 5019func (m *awsRestxml_deserializeOpPutBucketPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5020 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5021) { 5022 out, metadata, err = next.HandleDeserialize(ctx, in) 5023 if err != nil { 5024 return out, metadata, err 5025 } 5026 5027 response, ok := out.RawResponse.(*smithyhttp.Response) 5028 if !ok { 5029 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5030 } 5031 5032 if response.StatusCode < 200 || response.StatusCode >= 300 { 5033 return out, metadata, awsRestxml_deserializeOpErrorPutBucketPolicy(response, &metadata) 5034 } 5035 output := &PutBucketPolicyOutput{} 5036 out.Result = output 5037 5038 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5039 return out, metadata, &smithy.DeserializationError{ 5040 Err: fmt.Errorf("failed to discard response body, %w", err), 5041 } 5042 } 5043 5044 return out, metadata, err 5045} 5046 5047func awsRestxml_deserializeOpErrorPutBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5048 var errorBuffer bytes.Buffer 5049 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5050 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5051 } 5052 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5053 5054 errorCode := "UnknownError" 5055 errorMessage := errorCode 5056 5057 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5058 IsWrappedWithErrorTag: true, 5059 }) 5060 if err != nil { 5061 return err 5062 } 5063 if hostID := errorComponents.HostID; len(hostID) != 0 { 5064 s3shared.SetHostIDMetadata(metadata, hostID) 5065 } 5066 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5067 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5068 } 5069 if len(errorComponents.Code) != 0 { 5070 errorCode = errorComponents.Code 5071 } 5072 if len(errorComponents.Message) != 0 { 5073 errorMessage = errorComponents.Message 5074 } 5075 errorBody.Seek(0, io.SeekStart) 5076 switch { 5077 default: 5078 genericError := &smithy.GenericAPIError{ 5079 Code: errorCode, 5080 Message: errorMessage, 5081 } 5082 return genericError 5083 5084 } 5085} 5086 5087type awsRestxml_deserializeOpPutBucketTagging struct { 5088} 5089 5090func (*awsRestxml_deserializeOpPutBucketTagging) ID() string { 5091 return "OperationDeserializer" 5092} 5093 5094func (m *awsRestxml_deserializeOpPutBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5095 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5096) { 5097 out, metadata, err = next.HandleDeserialize(ctx, in) 5098 if err != nil { 5099 return out, metadata, err 5100 } 5101 5102 response, ok := out.RawResponse.(*smithyhttp.Response) 5103 if !ok { 5104 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5105 } 5106 5107 if response.StatusCode < 200 || response.StatusCode >= 300 { 5108 return out, metadata, awsRestxml_deserializeOpErrorPutBucketTagging(response, &metadata) 5109 } 5110 output := &PutBucketTaggingOutput{} 5111 out.Result = output 5112 5113 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5114 return out, metadata, &smithy.DeserializationError{ 5115 Err: fmt.Errorf("failed to discard response body, %w", err), 5116 } 5117 } 5118 5119 return out, metadata, err 5120} 5121 5122func awsRestxml_deserializeOpErrorPutBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5123 var errorBuffer bytes.Buffer 5124 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5125 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5126 } 5127 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5128 5129 errorCode := "UnknownError" 5130 errorMessage := errorCode 5131 5132 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5133 IsWrappedWithErrorTag: true, 5134 }) 5135 if err != nil { 5136 return err 5137 } 5138 if hostID := errorComponents.HostID; len(hostID) != 0 { 5139 s3shared.SetHostIDMetadata(metadata, hostID) 5140 } 5141 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5142 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5143 } 5144 if len(errorComponents.Code) != 0 { 5145 errorCode = errorComponents.Code 5146 } 5147 if len(errorComponents.Message) != 0 { 5148 errorMessage = errorComponents.Message 5149 } 5150 errorBody.Seek(0, io.SeekStart) 5151 switch { 5152 default: 5153 genericError := &smithy.GenericAPIError{ 5154 Code: errorCode, 5155 Message: errorMessage, 5156 } 5157 return genericError 5158 5159 } 5160} 5161 5162type awsRestxml_deserializeOpPutJobTagging struct { 5163} 5164 5165func (*awsRestxml_deserializeOpPutJobTagging) ID() string { 5166 return "OperationDeserializer" 5167} 5168 5169func (m *awsRestxml_deserializeOpPutJobTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5170 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5171) { 5172 out, metadata, err = next.HandleDeserialize(ctx, in) 5173 if err != nil { 5174 return out, metadata, err 5175 } 5176 5177 response, ok := out.RawResponse.(*smithyhttp.Response) 5178 if !ok { 5179 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5180 } 5181 5182 if response.StatusCode < 200 || response.StatusCode >= 300 { 5183 return out, metadata, awsRestxml_deserializeOpErrorPutJobTagging(response, &metadata) 5184 } 5185 output := &PutJobTaggingOutput{} 5186 out.Result = output 5187 5188 return out, metadata, err 5189} 5190 5191func awsRestxml_deserializeOpErrorPutJobTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5192 var errorBuffer bytes.Buffer 5193 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5194 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5195 } 5196 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5197 5198 errorCode := "UnknownError" 5199 errorMessage := errorCode 5200 5201 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5202 IsWrappedWithErrorTag: true, 5203 }) 5204 if err != nil { 5205 return err 5206 } 5207 if hostID := errorComponents.HostID; len(hostID) != 0 { 5208 s3shared.SetHostIDMetadata(metadata, hostID) 5209 } 5210 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5211 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5212 } 5213 if len(errorComponents.Code) != 0 { 5214 errorCode = errorComponents.Code 5215 } 5216 if len(errorComponents.Message) != 0 { 5217 errorMessage = errorComponents.Message 5218 } 5219 errorBody.Seek(0, io.SeekStart) 5220 switch { 5221 case strings.EqualFold("InternalServiceException", errorCode): 5222 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 5223 5224 case strings.EqualFold("NotFoundException", errorCode): 5225 return awsRestxml_deserializeErrorNotFoundException(response, errorBody) 5226 5227 case strings.EqualFold("TooManyRequestsException", errorCode): 5228 return awsRestxml_deserializeErrorTooManyRequestsException(response, errorBody) 5229 5230 case strings.EqualFold("TooManyTagsException", errorCode): 5231 return awsRestxml_deserializeErrorTooManyTagsException(response, errorBody) 5232 5233 default: 5234 genericError := &smithy.GenericAPIError{ 5235 Code: errorCode, 5236 Message: errorMessage, 5237 } 5238 return genericError 5239 5240 } 5241} 5242 5243type awsRestxml_deserializeOpPutPublicAccessBlock struct { 5244} 5245 5246func (*awsRestxml_deserializeOpPutPublicAccessBlock) ID() string { 5247 return "OperationDeserializer" 5248} 5249 5250func (m *awsRestxml_deserializeOpPutPublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5251 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5252) { 5253 out, metadata, err = next.HandleDeserialize(ctx, in) 5254 if err != nil { 5255 return out, metadata, err 5256 } 5257 5258 response, ok := out.RawResponse.(*smithyhttp.Response) 5259 if !ok { 5260 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5261 } 5262 5263 if response.StatusCode < 200 || response.StatusCode >= 300 { 5264 return out, metadata, awsRestxml_deserializeOpErrorPutPublicAccessBlock(response, &metadata) 5265 } 5266 output := &PutPublicAccessBlockOutput{} 5267 out.Result = output 5268 5269 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5270 return out, metadata, &smithy.DeserializationError{ 5271 Err: fmt.Errorf("failed to discard response body, %w", err), 5272 } 5273 } 5274 5275 return out, metadata, err 5276} 5277 5278func awsRestxml_deserializeOpErrorPutPublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5279 var errorBuffer bytes.Buffer 5280 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5281 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5282 } 5283 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5284 5285 errorCode := "UnknownError" 5286 errorMessage := errorCode 5287 5288 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5289 IsWrappedWithErrorTag: true, 5290 }) 5291 if err != nil { 5292 return err 5293 } 5294 if hostID := errorComponents.HostID; len(hostID) != 0 { 5295 s3shared.SetHostIDMetadata(metadata, hostID) 5296 } 5297 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5298 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5299 } 5300 if len(errorComponents.Code) != 0 { 5301 errorCode = errorComponents.Code 5302 } 5303 if len(errorComponents.Message) != 0 { 5304 errorMessage = errorComponents.Message 5305 } 5306 errorBody.Seek(0, io.SeekStart) 5307 switch { 5308 default: 5309 genericError := &smithy.GenericAPIError{ 5310 Code: errorCode, 5311 Message: errorMessage, 5312 } 5313 return genericError 5314 5315 } 5316} 5317 5318type awsRestxml_deserializeOpPutStorageLensConfiguration struct { 5319} 5320 5321func (*awsRestxml_deserializeOpPutStorageLensConfiguration) ID() string { 5322 return "OperationDeserializer" 5323} 5324 5325func (m *awsRestxml_deserializeOpPutStorageLensConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5326 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5327) { 5328 out, metadata, err = next.HandleDeserialize(ctx, in) 5329 if err != nil { 5330 return out, metadata, err 5331 } 5332 5333 response, ok := out.RawResponse.(*smithyhttp.Response) 5334 if !ok { 5335 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5336 } 5337 5338 if response.StatusCode < 200 || response.StatusCode >= 300 { 5339 return out, metadata, awsRestxml_deserializeOpErrorPutStorageLensConfiguration(response, &metadata) 5340 } 5341 output := &PutStorageLensConfigurationOutput{} 5342 out.Result = output 5343 5344 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5345 return out, metadata, &smithy.DeserializationError{ 5346 Err: fmt.Errorf("failed to discard response body, %w", err), 5347 } 5348 } 5349 5350 return out, metadata, err 5351} 5352 5353func awsRestxml_deserializeOpErrorPutStorageLensConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5354 var errorBuffer bytes.Buffer 5355 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5356 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5357 } 5358 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5359 5360 errorCode := "UnknownError" 5361 errorMessage := errorCode 5362 5363 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5364 IsWrappedWithErrorTag: true, 5365 }) 5366 if err != nil { 5367 return err 5368 } 5369 if hostID := errorComponents.HostID; len(hostID) != 0 { 5370 s3shared.SetHostIDMetadata(metadata, hostID) 5371 } 5372 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5373 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5374 } 5375 if len(errorComponents.Code) != 0 { 5376 errorCode = errorComponents.Code 5377 } 5378 if len(errorComponents.Message) != 0 { 5379 errorMessage = errorComponents.Message 5380 } 5381 errorBody.Seek(0, io.SeekStart) 5382 switch { 5383 default: 5384 genericError := &smithy.GenericAPIError{ 5385 Code: errorCode, 5386 Message: errorMessage, 5387 } 5388 return genericError 5389 5390 } 5391} 5392 5393type awsRestxml_deserializeOpPutStorageLensConfigurationTagging struct { 5394} 5395 5396func (*awsRestxml_deserializeOpPutStorageLensConfigurationTagging) ID() string { 5397 return "OperationDeserializer" 5398} 5399 5400func (m *awsRestxml_deserializeOpPutStorageLensConfigurationTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5401 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5402) { 5403 out, metadata, err = next.HandleDeserialize(ctx, in) 5404 if err != nil { 5405 return out, metadata, err 5406 } 5407 5408 response, ok := out.RawResponse.(*smithyhttp.Response) 5409 if !ok { 5410 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5411 } 5412 5413 if response.StatusCode < 200 || response.StatusCode >= 300 { 5414 return out, metadata, awsRestxml_deserializeOpErrorPutStorageLensConfigurationTagging(response, &metadata) 5415 } 5416 output := &PutStorageLensConfigurationTaggingOutput{} 5417 out.Result = output 5418 5419 return out, metadata, err 5420} 5421 5422func awsRestxml_deserializeOpErrorPutStorageLensConfigurationTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5423 var errorBuffer bytes.Buffer 5424 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5425 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5426 } 5427 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5428 5429 errorCode := "UnknownError" 5430 errorMessage := errorCode 5431 5432 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5433 IsWrappedWithErrorTag: true, 5434 }) 5435 if err != nil { 5436 return err 5437 } 5438 if hostID := errorComponents.HostID; len(hostID) != 0 { 5439 s3shared.SetHostIDMetadata(metadata, hostID) 5440 } 5441 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5442 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5443 } 5444 if len(errorComponents.Code) != 0 { 5445 errorCode = errorComponents.Code 5446 } 5447 if len(errorComponents.Message) != 0 { 5448 errorMessage = errorComponents.Message 5449 } 5450 errorBody.Seek(0, io.SeekStart) 5451 switch { 5452 default: 5453 genericError := &smithy.GenericAPIError{ 5454 Code: errorCode, 5455 Message: errorMessage, 5456 } 5457 return genericError 5458 5459 } 5460} 5461 5462type awsRestxml_deserializeOpUpdateJobPriority struct { 5463} 5464 5465func (*awsRestxml_deserializeOpUpdateJobPriority) ID() string { 5466 return "OperationDeserializer" 5467} 5468 5469func (m *awsRestxml_deserializeOpUpdateJobPriority) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5470 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5471) { 5472 out, metadata, err = next.HandleDeserialize(ctx, in) 5473 if err != nil { 5474 return out, metadata, err 5475 } 5476 5477 response, ok := out.RawResponse.(*smithyhttp.Response) 5478 if !ok { 5479 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5480 } 5481 5482 if response.StatusCode < 200 || response.StatusCode >= 300 { 5483 return out, metadata, awsRestxml_deserializeOpErrorUpdateJobPriority(response, &metadata) 5484 } 5485 output := &UpdateJobPriorityOutput{} 5486 out.Result = output 5487 5488 var buff [1024]byte 5489 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5490 body := io.TeeReader(response.Body, ringBuffer) 5491 rootDecoder := xml.NewDecoder(body) 5492 t, err := smithyxml.FetchRootElement(rootDecoder) 5493 if err == io.EOF { 5494 return out, metadata, nil 5495 } 5496 if err != nil { 5497 var snapshot bytes.Buffer 5498 io.Copy(&snapshot, ringBuffer) 5499 return out, metadata, &smithy.DeserializationError{ 5500 Err: fmt.Errorf("failed to decode response body, %w", err), 5501 Snapshot: snapshot.Bytes(), 5502 } 5503 } 5504 5505 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5506 err = awsRestxml_deserializeOpDocumentUpdateJobPriorityOutput(&output, decoder) 5507 if err != nil { 5508 var snapshot bytes.Buffer 5509 io.Copy(&snapshot, ringBuffer) 5510 return out, metadata, &smithy.DeserializationError{ 5511 Err: fmt.Errorf("failed to decode response body, %w", err), 5512 Snapshot: snapshot.Bytes(), 5513 } 5514 } 5515 5516 return out, metadata, err 5517} 5518 5519func awsRestxml_deserializeOpErrorUpdateJobPriority(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5520 var errorBuffer bytes.Buffer 5521 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5522 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5523 } 5524 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5525 5526 errorCode := "UnknownError" 5527 errorMessage := errorCode 5528 5529 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5530 IsWrappedWithErrorTag: true, 5531 }) 5532 if err != nil { 5533 return err 5534 } 5535 if hostID := errorComponents.HostID; len(hostID) != 0 { 5536 s3shared.SetHostIDMetadata(metadata, hostID) 5537 } 5538 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5539 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5540 } 5541 if len(errorComponents.Code) != 0 { 5542 errorCode = errorComponents.Code 5543 } 5544 if len(errorComponents.Message) != 0 { 5545 errorMessage = errorComponents.Message 5546 } 5547 errorBody.Seek(0, io.SeekStart) 5548 switch { 5549 case strings.EqualFold("BadRequestException", errorCode): 5550 return awsRestxml_deserializeErrorBadRequestException(response, errorBody) 5551 5552 case strings.EqualFold("InternalServiceException", errorCode): 5553 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 5554 5555 case strings.EqualFold("NotFoundException", errorCode): 5556 return awsRestxml_deserializeErrorNotFoundException(response, errorBody) 5557 5558 case strings.EqualFold("TooManyRequestsException", errorCode): 5559 return awsRestxml_deserializeErrorTooManyRequestsException(response, errorBody) 5560 5561 default: 5562 genericError := &smithy.GenericAPIError{ 5563 Code: errorCode, 5564 Message: errorMessage, 5565 } 5566 return genericError 5567 5568 } 5569} 5570 5571func awsRestxml_deserializeOpDocumentUpdateJobPriorityOutput(v **UpdateJobPriorityOutput, decoder smithyxml.NodeDecoder) error { 5572 if v == nil { 5573 return fmt.Errorf("unexpected nil of type %T", v) 5574 } 5575 var sv *UpdateJobPriorityOutput 5576 if *v == nil { 5577 sv = &UpdateJobPriorityOutput{} 5578 } else { 5579 sv = *v 5580 } 5581 5582 for { 5583 t, done, err := decoder.Token() 5584 if err != nil { 5585 return err 5586 } 5587 if done { 5588 break 5589 } 5590 originalDecoder := decoder 5591 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5592 switch { 5593 case strings.EqualFold("JobId", t.Name.Local): 5594 val, err := decoder.Value() 5595 if err != nil { 5596 return err 5597 } 5598 if val == nil { 5599 break 5600 } 5601 { 5602 xtv := string(val) 5603 sv.JobId = ptr.String(xtv) 5604 } 5605 5606 case strings.EqualFold("Priority", t.Name.Local): 5607 val, err := decoder.Value() 5608 if err != nil { 5609 return err 5610 } 5611 if val == nil { 5612 break 5613 } 5614 { 5615 xtv := string(val) 5616 i64, err := strconv.ParseInt(xtv, 10, 64) 5617 if err != nil { 5618 return err 5619 } 5620 sv.Priority = int32(i64) 5621 } 5622 5623 default: 5624 // Do nothing and ignore the unexpected tag element 5625 err = decoder.Decoder.Skip() 5626 if err != nil { 5627 return err 5628 } 5629 5630 } 5631 decoder = originalDecoder 5632 } 5633 *v = sv 5634 return nil 5635} 5636 5637type awsRestxml_deserializeOpUpdateJobStatus struct { 5638} 5639 5640func (*awsRestxml_deserializeOpUpdateJobStatus) ID() string { 5641 return "OperationDeserializer" 5642} 5643 5644func (m *awsRestxml_deserializeOpUpdateJobStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5645 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5646) { 5647 out, metadata, err = next.HandleDeserialize(ctx, in) 5648 if err != nil { 5649 return out, metadata, err 5650 } 5651 5652 response, ok := out.RawResponse.(*smithyhttp.Response) 5653 if !ok { 5654 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5655 } 5656 5657 if response.StatusCode < 200 || response.StatusCode >= 300 { 5658 return out, metadata, awsRestxml_deserializeOpErrorUpdateJobStatus(response, &metadata) 5659 } 5660 output := &UpdateJobStatusOutput{} 5661 out.Result = output 5662 5663 var buff [1024]byte 5664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5665 body := io.TeeReader(response.Body, ringBuffer) 5666 rootDecoder := xml.NewDecoder(body) 5667 t, err := smithyxml.FetchRootElement(rootDecoder) 5668 if err == io.EOF { 5669 return out, metadata, nil 5670 } 5671 if err != nil { 5672 var snapshot bytes.Buffer 5673 io.Copy(&snapshot, ringBuffer) 5674 return out, metadata, &smithy.DeserializationError{ 5675 Err: fmt.Errorf("failed to decode response body, %w", err), 5676 Snapshot: snapshot.Bytes(), 5677 } 5678 } 5679 5680 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5681 err = awsRestxml_deserializeOpDocumentUpdateJobStatusOutput(&output, decoder) 5682 if err != nil { 5683 var snapshot bytes.Buffer 5684 io.Copy(&snapshot, ringBuffer) 5685 return out, metadata, &smithy.DeserializationError{ 5686 Err: fmt.Errorf("failed to decode response body, %w", err), 5687 Snapshot: snapshot.Bytes(), 5688 } 5689 } 5690 5691 return out, metadata, err 5692} 5693 5694func awsRestxml_deserializeOpErrorUpdateJobStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5695 var errorBuffer bytes.Buffer 5696 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5697 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5698 } 5699 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5700 5701 errorCode := "UnknownError" 5702 errorMessage := errorCode 5703 5704 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5705 IsWrappedWithErrorTag: true, 5706 }) 5707 if err != nil { 5708 return err 5709 } 5710 if hostID := errorComponents.HostID; len(hostID) != 0 { 5711 s3shared.SetHostIDMetadata(metadata, hostID) 5712 } 5713 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5714 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5715 } 5716 if len(errorComponents.Code) != 0 { 5717 errorCode = errorComponents.Code 5718 } 5719 if len(errorComponents.Message) != 0 { 5720 errorMessage = errorComponents.Message 5721 } 5722 errorBody.Seek(0, io.SeekStart) 5723 switch { 5724 case strings.EqualFold("BadRequestException", errorCode): 5725 return awsRestxml_deserializeErrorBadRequestException(response, errorBody) 5726 5727 case strings.EqualFold("InternalServiceException", errorCode): 5728 return awsRestxml_deserializeErrorInternalServiceException(response, errorBody) 5729 5730 case strings.EqualFold("JobStatusException", errorCode): 5731 return awsRestxml_deserializeErrorJobStatusException(response, errorBody) 5732 5733 case strings.EqualFold("NotFoundException", errorCode): 5734 return awsRestxml_deserializeErrorNotFoundException(response, errorBody) 5735 5736 case strings.EqualFold("TooManyRequestsException", errorCode): 5737 return awsRestxml_deserializeErrorTooManyRequestsException(response, errorBody) 5738 5739 default: 5740 genericError := &smithy.GenericAPIError{ 5741 Code: errorCode, 5742 Message: errorMessage, 5743 } 5744 return genericError 5745 5746 } 5747} 5748 5749func awsRestxml_deserializeOpDocumentUpdateJobStatusOutput(v **UpdateJobStatusOutput, decoder smithyxml.NodeDecoder) error { 5750 if v == nil { 5751 return fmt.Errorf("unexpected nil of type %T", v) 5752 } 5753 var sv *UpdateJobStatusOutput 5754 if *v == nil { 5755 sv = &UpdateJobStatusOutput{} 5756 } else { 5757 sv = *v 5758 } 5759 5760 for { 5761 t, done, err := decoder.Token() 5762 if err != nil { 5763 return err 5764 } 5765 if done { 5766 break 5767 } 5768 originalDecoder := decoder 5769 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5770 switch { 5771 case strings.EqualFold("JobId", t.Name.Local): 5772 val, err := decoder.Value() 5773 if err != nil { 5774 return err 5775 } 5776 if val == nil { 5777 break 5778 } 5779 { 5780 xtv := string(val) 5781 sv.JobId = ptr.String(xtv) 5782 } 5783 5784 case strings.EqualFold("Status", t.Name.Local): 5785 val, err := decoder.Value() 5786 if err != nil { 5787 return err 5788 } 5789 if val == nil { 5790 break 5791 } 5792 { 5793 xtv := string(val) 5794 sv.Status = types.JobStatus(xtv) 5795 } 5796 5797 case strings.EqualFold("StatusUpdateReason", t.Name.Local): 5798 val, err := decoder.Value() 5799 if err != nil { 5800 return err 5801 } 5802 if val == nil { 5803 break 5804 } 5805 { 5806 xtv := string(val) 5807 sv.StatusUpdateReason = ptr.String(xtv) 5808 } 5809 5810 default: 5811 // Do nothing and ignore the unexpected tag element 5812 err = decoder.Decoder.Skip() 5813 if err != nil { 5814 return err 5815 } 5816 5817 } 5818 decoder = originalDecoder 5819 } 5820 *v = sv 5821 return nil 5822} 5823 5824func awsRestxml_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5825 output := &types.BadRequestException{} 5826 var buff [1024]byte 5827 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5828 body := io.TeeReader(errorBody, ringBuffer) 5829 rootDecoder := xml.NewDecoder(body) 5830 t, err := smithyxml.FetchRootElement(rootDecoder) 5831 if err == io.EOF { 5832 return output 5833 } 5834 if err != nil { 5835 var snapshot bytes.Buffer 5836 io.Copy(&snapshot, ringBuffer) 5837 return &smithy.DeserializationError{ 5838 Err: fmt.Errorf("failed to decode response body, %w", err), 5839 Snapshot: snapshot.Bytes(), 5840 } 5841 } 5842 5843 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5844 t, err = decoder.GetElement("Error") 5845 if err != nil { 5846 var snapshot bytes.Buffer 5847 io.Copy(&snapshot, ringBuffer) 5848 return &smithy.DeserializationError{ 5849 Err: fmt.Errorf("failed to decode response body, %w", err), 5850 Snapshot: snapshot.Bytes(), 5851 } 5852 } 5853 5854 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5855 err = awsRestxml_deserializeDocumentBadRequestException(&output, decoder) 5856 if err != nil { 5857 var snapshot bytes.Buffer 5858 io.Copy(&snapshot, ringBuffer) 5859 return &smithy.DeserializationError{ 5860 Err: fmt.Errorf("failed to decode response body, %w", err), 5861 Snapshot: snapshot.Bytes(), 5862 } 5863 } 5864 5865 return output 5866} 5867 5868func awsRestxml_deserializeErrorBucketAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5869 output := &types.BucketAlreadyExists{} 5870 return output 5871} 5872 5873func awsRestxml_deserializeErrorBucketAlreadyOwnedByYou(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5874 output := &types.BucketAlreadyOwnedByYou{} 5875 return output 5876} 5877 5878func awsRestxml_deserializeErrorIdempotencyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5879 output := &types.IdempotencyException{} 5880 var buff [1024]byte 5881 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5882 body := io.TeeReader(errorBody, ringBuffer) 5883 rootDecoder := xml.NewDecoder(body) 5884 t, err := smithyxml.FetchRootElement(rootDecoder) 5885 if err == io.EOF { 5886 return output 5887 } 5888 if err != nil { 5889 var snapshot bytes.Buffer 5890 io.Copy(&snapshot, ringBuffer) 5891 return &smithy.DeserializationError{ 5892 Err: fmt.Errorf("failed to decode response body, %w", err), 5893 Snapshot: snapshot.Bytes(), 5894 } 5895 } 5896 5897 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5898 t, err = decoder.GetElement("Error") 5899 if err != nil { 5900 var snapshot bytes.Buffer 5901 io.Copy(&snapshot, ringBuffer) 5902 return &smithy.DeserializationError{ 5903 Err: fmt.Errorf("failed to decode response body, %w", err), 5904 Snapshot: snapshot.Bytes(), 5905 } 5906 } 5907 5908 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5909 err = awsRestxml_deserializeDocumentIdempotencyException(&output, decoder) 5910 if err != nil { 5911 var snapshot bytes.Buffer 5912 io.Copy(&snapshot, ringBuffer) 5913 return &smithy.DeserializationError{ 5914 Err: fmt.Errorf("failed to decode response body, %w", err), 5915 Snapshot: snapshot.Bytes(), 5916 } 5917 } 5918 5919 return output 5920} 5921 5922func awsRestxml_deserializeErrorInternalServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5923 output := &types.InternalServiceException{} 5924 var buff [1024]byte 5925 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5926 body := io.TeeReader(errorBody, ringBuffer) 5927 rootDecoder := xml.NewDecoder(body) 5928 t, err := smithyxml.FetchRootElement(rootDecoder) 5929 if err == io.EOF { 5930 return output 5931 } 5932 if err != nil { 5933 var snapshot bytes.Buffer 5934 io.Copy(&snapshot, ringBuffer) 5935 return &smithy.DeserializationError{ 5936 Err: fmt.Errorf("failed to decode response body, %w", err), 5937 Snapshot: snapshot.Bytes(), 5938 } 5939 } 5940 5941 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5942 t, err = decoder.GetElement("Error") 5943 if err != nil { 5944 var snapshot bytes.Buffer 5945 io.Copy(&snapshot, ringBuffer) 5946 return &smithy.DeserializationError{ 5947 Err: fmt.Errorf("failed to decode response body, %w", err), 5948 Snapshot: snapshot.Bytes(), 5949 } 5950 } 5951 5952 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5953 err = awsRestxml_deserializeDocumentInternalServiceException(&output, decoder) 5954 if err != nil { 5955 var snapshot bytes.Buffer 5956 io.Copy(&snapshot, ringBuffer) 5957 return &smithy.DeserializationError{ 5958 Err: fmt.Errorf("failed to decode response body, %w", err), 5959 Snapshot: snapshot.Bytes(), 5960 } 5961 } 5962 5963 return output 5964} 5965 5966func awsRestxml_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5967 output := &types.InvalidNextTokenException{} 5968 var buff [1024]byte 5969 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5970 body := io.TeeReader(errorBody, ringBuffer) 5971 rootDecoder := xml.NewDecoder(body) 5972 t, err := smithyxml.FetchRootElement(rootDecoder) 5973 if err == io.EOF { 5974 return output 5975 } 5976 if err != nil { 5977 var snapshot bytes.Buffer 5978 io.Copy(&snapshot, ringBuffer) 5979 return &smithy.DeserializationError{ 5980 Err: fmt.Errorf("failed to decode response body, %w", err), 5981 Snapshot: snapshot.Bytes(), 5982 } 5983 } 5984 5985 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5986 t, err = decoder.GetElement("Error") 5987 if err != nil { 5988 var snapshot bytes.Buffer 5989 io.Copy(&snapshot, ringBuffer) 5990 return &smithy.DeserializationError{ 5991 Err: fmt.Errorf("failed to decode response body, %w", err), 5992 Snapshot: snapshot.Bytes(), 5993 } 5994 } 5995 5996 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5997 err = awsRestxml_deserializeDocumentInvalidNextTokenException(&output, decoder) 5998 if err != nil { 5999 var snapshot bytes.Buffer 6000 io.Copy(&snapshot, ringBuffer) 6001 return &smithy.DeserializationError{ 6002 Err: fmt.Errorf("failed to decode response body, %w", err), 6003 Snapshot: snapshot.Bytes(), 6004 } 6005 } 6006 6007 return output 6008} 6009 6010func awsRestxml_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6011 output := &types.InvalidRequestException{} 6012 var buff [1024]byte 6013 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6014 body := io.TeeReader(errorBody, ringBuffer) 6015 rootDecoder := xml.NewDecoder(body) 6016 t, err := smithyxml.FetchRootElement(rootDecoder) 6017 if err == io.EOF { 6018 return output 6019 } 6020 if err != nil { 6021 var snapshot bytes.Buffer 6022 io.Copy(&snapshot, ringBuffer) 6023 return &smithy.DeserializationError{ 6024 Err: fmt.Errorf("failed to decode response body, %w", err), 6025 Snapshot: snapshot.Bytes(), 6026 } 6027 } 6028 6029 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6030 t, err = decoder.GetElement("Error") 6031 if err != nil { 6032 var snapshot bytes.Buffer 6033 io.Copy(&snapshot, ringBuffer) 6034 return &smithy.DeserializationError{ 6035 Err: fmt.Errorf("failed to decode response body, %w", err), 6036 Snapshot: snapshot.Bytes(), 6037 } 6038 } 6039 6040 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6041 err = awsRestxml_deserializeDocumentInvalidRequestException(&output, decoder) 6042 if err != nil { 6043 var snapshot bytes.Buffer 6044 io.Copy(&snapshot, ringBuffer) 6045 return &smithy.DeserializationError{ 6046 Err: fmt.Errorf("failed to decode response body, %w", err), 6047 Snapshot: snapshot.Bytes(), 6048 } 6049 } 6050 6051 return output 6052} 6053 6054func awsRestxml_deserializeErrorJobStatusException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6055 output := &types.JobStatusException{} 6056 var buff [1024]byte 6057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6058 body := io.TeeReader(errorBody, ringBuffer) 6059 rootDecoder := xml.NewDecoder(body) 6060 t, err := smithyxml.FetchRootElement(rootDecoder) 6061 if err == io.EOF { 6062 return output 6063 } 6064 if err != nil { 6065 var snapshot bytes.Buffer 6066 io.Copy(&snapshot, ringBuffer) 6067 return &smithy.DeserializationError{ 6068 Err: fmt.Errorf("failed to decode response body, %w", err), 6069 Snapshot: snapshot.Bytes(), 6070 } 6071 } 6072 6073 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6074 t, err = decoder.GetElement("Error") 6075 if err != nil { 6076 var snapshot bytes.Buffer 6077 io.Copy(&snapshot, ringBuffer) 6078 return &smithy.DeserializationError{ 6079 Err: fmt.Errorf("failed to decode response body, %w", err), 6080 Snapshot: snapshot.Bytes(), 6081 } 6082 } 6083 6084 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6085 err = awsRestxml_deserializeDocumentJobStatusException(&output, decoder) 6086 if err != nil { 6087 var snapshot bytes.Buffer 6088 io.Copy(&snapshot, ringBuffer) 6089 return &smithy.DeserializationError{ 6090 Err: fmt.Errorf("failed to decode response body, %w", err), 6091 Snapshot: snapshot.Bytes(), 6092 } 6093 } 6094 6095 return output 6096} 6097 6098func awsRestxml_deserializeErrorNoSuchPublicAccessBlockConfiguration(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6099 output := &types.NoSuchPublicAccessBlockConfiguration{} 6100 var buff [1024]byte 6101 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6102 body := io.TeeReader(errorBody, ringBuffer) 6103 rootDecoder := xml.NewDecoder(body) 6104 t, err := smithyxml.FetchRootElement(rootDecoder) 6105 if err == io.EOF { 6106 return output 6107 } 6108 if err != nil { 6109 var snapshot bytes.Buffer 6110 io.Copy(&snapshot, ringBuffer) 6111 return &smithy.DeserializationError{ 6112 Err: fmt.Errorf("failed to decode response body, %w", err), 6113 Snapshot: snapshot.Bytes(), 6114 } 6115 } 6116 6117 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6118 t, err = decoder.GetElement("Error") 6119 if err != nil { 6120 var snapshot bytes.Buffer 6121 io.Copy(&snapshot, ringBuffer) 6122 return &smithy.DeserializationError{ 6123 Err: fmt.Errorf("failed to decode response body, %w", err), 6124 Snapshot: snapshot.Bytes(), 6125 } 6126 } 6127 6128 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6129 err = awsRestxml_deserializeDocumentNoSuchPublicAccessBlockConfiguration(&output, decoder) 6130 if err != nil { 6131 var snapshot bytes.Buffer 6132 io.Copy(&snapshot, ringBuffer) 6133 return &smithy.DeserializationError{ 6134 Err: fmt.Errorf("failed to decode response body, %w", err), 6135 Snapshot: snapshot.Bytes(), 6136 } 6137 } 6138 6139 return output 6140} 6141 6142func awsRestxml_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6143 output := &types.NotFoundException{} 6144 var buff [1024]byte 6145 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6146 body := io.TeeReader(errorBody, ringBuffer) 6147 rootDecoder := xml.NewDecoder(body) 6148 t, err := smithyxml.FetchRootElement(rootDecoder) 6149 if err == io.EOF { 6150 return output 6151 } 6152 if err != nil { 6153 var snapshot bytes.Buffer 6154 io.Copy(&snapshot, ringBuffer) 6155 return &smithy.DeserializationError{ 6156 Err: fmt.Errorf("failed to decode response body, %w", err), 6157 Snapshot: snapshot.Bytes(), 6158 } 6159 } 6160 6161 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6162 t, err = decoder.GetElement("Error") 6163 if err != nil { 6164 var snapshot bytes.Buffer 6165 io.Copy(&snapshot, ringBuffer) 6166 return &smithy.DeserializationError{ 6167 Err: fmt.Errorf("failed to decode response body, %w", err), 6168 Snapshot: snapshot.Bytes(), 6169 } 6170 } 6171 6172 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6173 err = awsRestxml_deserializeDocumentNotFoundException(&output, decoder) 6174 if err != nil { 6175 var snapshot bytes.Buffer 6176 io.Copy(&snapshot, ringBuffer) 6177 return &smithy.DeserializationError{ 6178 Err: fmt.Errorf("failed to decode response body, %w", err), 6179 Snapshot: snapshot.Bytes(), 6180 } 6181 } 6182 6183 return output 6184} 6185 6186func awsRestxml_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6187 output := &types.TooManyRequestsException{} 6188 var buff [1024]byte 6189 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6190 body := io.TeeReader(errorBody, ringBuffer) 6191 rootDecoder := xml.NewDecoder(body) 6192 t, err := smithyxml.FetchRootElement(rootDecoder) 6193 if err == io.EOF { 6194 return output 6195 } 6196 if err != nil { 6197 var snapshot bytes.Buffer 6198 io.Copy(&snapshot, ringBuffer) 6199 return &smithy.DeserializationError{ 6200 Err: fmt.Errorf("failed to decode response body, %w", err), 6201 Snapshot: snapshot.Bytes(), 6202 } 6203 } 6204 6205 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6206 t, err = decoder.GetElement("Error") 6207 if err != nil { 6208 var snapshot bytes.Buffer 6209 io.Copy(&snapshot, ringBuffer) 6210 return &smithy.DeserializationError{ 6211 Err: fmt.Errorf("failed to decode response body, %w", err), 6212 Snapshot: snapshot.Bytes(), 6213 } 6214 } 6215 6216 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6217 err = awsRestxml_deserializeDocumentTooManyRequestsException(&output, decoder) 6218 if err != nil { 6219 var snapshot bytes.Buffer 6220 io.Copy(&snapshot, ringBuffer) 6221 return &smithy.DeserializationError{ 6222 Err: fmt.Errorf("failed to decode response body, %w", err), 6223 Snapshot: snapshot.Bytes(), 6224 } 6225 } 6226 6227 return output 6228} 6229 6230func awsRestxml_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6231 output := &types.TooManyTagsException{} 6232 var buff [1024]byte 6233 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6234 body := io.TeeReader(errorBody, ringBuffer) 6235 rootDecoder := xml.NewDecoder(body) 6236 t, err := smithyxml.FetchRootElement(rootDecoder) 6237 if err == io.EOF { 6238 return output 6239 } 6240 if err != nil { 6241 var snapshot bytes.Buffer 6242 io.Copy(&snapshot, ringBuffer) 6243 return &smithy.DeserializationError{ 6244 Err: fmt.Errorf("failed to decode response body, %w", err), 6245 Snapshot: snapshot.Bytes(), 6246 } 6247 } 6248 6249 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6250 t, err = decoder.GetElement("Error") 6251 if err != nil { 6252 var snapshot bytes.Buffer 6253 io.Copy(&snapshot, ringBuffer) 6254 return &smithy.DeserializationError{ 6255 Err: fmt.Errorf("failed to decode response body, %w", err), 6256 Snapshot: snapshot.Bytes(), 6257 } 6258 } 6259 6260 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6261 err = awsRestxml_deserializeDocumentTooManyTagsException(&output, decoder) 6262 if err != nil { 6263 var snapshot bytes.Buffer 6264 io.Copy(&snapshot, ringBuffer) 6265 return &smithy.DeserializationError{ 6266 Err: fmt.Errorf("failed to decode response body, %w", err), 6267 Snapshot: snapshot.Bytes(), 6268 } 6269 } 6270 6271 return output 6272} 6273 6274func awsRestxml_deserializeDocumentAbortIncompleteMultipartUpload(v **types.AbortIncompleteMultipartUpload, decoder smithyxml.NodeDecoder) error { 6275 if v == nil { 6276 return fmt.Errorf("unexpected nil of type %T", v) 6277 } 6278 var sv *types.AbortIncompleteMultipartUpload 6279 if *v == nil { 6280 sv = &types.AbortIncompleteMultipartUpload{} 6281 } else { 6282 sv = *v 6283 } 6284 6285 for { 6286 t, done, err := decoder.Token() 6287 if err != nil { 6288 return err 6289 } 6290 if done { 6291 break 6292 } 6293 originalDecoder := decoder 6294 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6295 switch { 6296 case strings.EqualFold("DaysAfterInitiation", t.Name.Local): 6297 val, err := decoder.Value() 6298 if err != nil { 6299 return err 6300 } 6301 if val == nil { 6302 break 6303 } 6304 { 6305 xtv := string(val) 6306 i64, err := strconv.ParseInt(xtv, 10, 64) 6307 if err != nil { 6308 return err 6309 } 6310 sv.DaysAfterInitiation = int32(i64) 6311 } 6312 6313 default: 6314 // Do nothing and ignore the unexpected tag element 6315 err = decoder.Decoder.Skip() 6316 if err != nil { 6317 return err 6318 } 6319 6320 } 6321 decoder = originalDecoder 6322 } 6323 *v = sv 6324 return nil 6325} 6326 6327func awsRestxml_deserializeDocumentAccessPoint(v **types.AccessPoint, decoder smithyxml.NodeDecoder) error { 6328 if v == nil { 6329 return fmt.Errorf("unexpected nil of type %T", v) 6330 } 6331 var sv *types.AccessPoint 6332 if *v == nil { 6333 sv = &types.AccessPoint{} 6334 } else { 6335 sv = *v 6336 } 6337 6338 for { 6339 t, done, err := decoder.Token() 6340 if err != nil { 6341 return err 6342 } 6343 if done { 6344 break 6345 } 6346 originalDecoder := decoder 6347 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6348 switch { 6349 case strings.EqualFold("AccessPointArn", t.Name.Local): 6350 val, err := decoder.Value() 6351 if err != nil { 6352 return err 6353 } 6354 if val == nil { 6355 break 6356 } 6357 { 6358 xtv := string(val) 6359 sv.AccessPointArn = ptr.String(xtv) 6360 } 6361 6362 case strings.EqualFold("Bucket", t.Name.Local): 6363 val, err := decoder.Value() 6364 if err != nil { 6365 return err 6366 } 6367 if val == nil { 6368 break 6369 } 6370 { 6371 xtv := string(val) 6372 sv.Bucket = ptr.String(xtv) 6373 } 6374 6375 case strings.EqualFold("Name", t.Name.Local): 6376 val, err := decoder.Value() 6377 if err != nil { 6378 return err 6379 } 6380 if val == nil { 6381 break 6382 } 6383 { 6384 xtv := string(val) 6385 sv.Name = ptr.String(xtv) 6386 } 6387 6388 case strings.EqualFold("NetworkOrigin", t.Name.Local): 6389 val, err := decoder.Value() 6390 if err != nil { 6391 return err 6392 } 6393 if val == nil { 6394 break 6395 } 6396 { 6397 xtv := string(val) 6398 sv.NetworkOrigin = types.NetworkOrigin(xtv) 6399 } 6400 6401 case strings.EqualFold("VpcConfiguration", t.Name.Local): 6402 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6403 if err := awsRestxml_deserializeDocumentVpcConfiguration(&sv.VpcConfiguration, nodeDecoder); err != nil { 6404 return err 6405 } 6406 6407 default: 6408 // Do nothing and ignore the unexpected tag element 6409 err = decoder.Decoder.Skip() 6410 if err != nil { 6411 return err 6412 } 6413 6414 } 6415 decoder = originalDecoder 6416 } 6417 *v = sv 6418 return nil 6419} 6420 6421func awsRestxml_deserializeDocumentAccessPointList(v *[]types.AccessPoint, decoder smithyxml.NodeDecoder) error { 6422 if v == nil { 6423 return fmt.Errorf("unexpected nil of type %T", v) 6424 } 6425 var sv []types.AccessPoint 6426 if *v == nil { 6427 sv = make([]types.AccessPoint, 0) 6428 } else { 6429 sv = *v 6430 } 6431 6432 originalDecoder := decoder 6433 for { 6434 t, done, err := decoder.Token() 6435 if err != nil { 6436 return err 6437 } 6438 if done { 6439 break 6440 } 6441 switch { 6442 case strings.EqualFold("AccessPoint", t.Name.Local): 6443 var col types.AccessPoint 6444 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6445 destAddr := &col 6446 if err := awsRestxml_deserializeDocumentAccessPoint(&destAddr, nodeDecoder); err != nil { 6447 return err 6448 } 6449 col = *destAddr 6450 sv = append(sv, col) 6451 6452 default: 6453 err = decoder.Decoder.Skip() 6454 if err != nil { 6455 return err 6456 } 6457 6458 } 6459 decoder = originalDecoder 6460 } 6461 *v = sv 6462 return nil 6463} 6464 6465func awsRestxml_deserializeDocumentAccessPointListUnwrapped(v *[]types.AccessPoint, decoder smithyxml.NodeDecoder) error { 6466 var sv []types.AccessPoint 6467 if *v == nil { 6468 sv = make([]types.AccessPoint, 0) 6469 } else { 6470 sv = *v 6471 } 6472 6473 switch { 6474 default: 6475 var mv types.AccessPoint 6476 t := decoder.StartEl 6477 _ = t 6478 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6479 destAddr := &mv 6480 if err := awsRestxml_deserializeDocumentAccessPoint(&destAddr, nodeDecoder); err != nil { 6481 return err 6482 } 6483 mv = *destAddr 6484 sv = append(sv, mv) 6485 } 6486 *v = sv 6487 return nil 6488} 6489func awsRestxml_deserializeDocumentAccountLevel(v **types.AccountLevel, decoder smithyxml.NodeDecoder) error { 6490 if v == nil { 6491 return fmt.Errorf("unexpected nil of type %T", v) 6492 } 6493 var sv *types.AccountLevel 6494 if *v == nil { 6495 sv = &types.AccountLevel{} 6496 } else { 6497 sv = *v 6498 } 6499 6500 for { 6501 t, done, err := decoder.Token() 6502 if err != nil { 6503 return err 6504 } 6505 if done { 6506 break 6507 } 6508 originalDecoder := decoder 6509 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6510 switch { 6511 case strings.EqualFold("ActivityMetrics", t.Name.Local): 6512 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6513 if err := awsRestxml_deserializeDocumentActivityMetrics(&sv.ActivityMetrics, nodeDecoder); err != nil { 6514 return err 6515 } 6516 6517 case strings.EqualFold("BucketLevel", t.Name.Local): 6518 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6519 if err := awsRestxml_deserializeDocumentBucketLevel(&sv.BucketLevel, nodeDecoder); err != nil { 6520 return err 6521 } 6522 6523 default: 6524 // Do nothing and ignore the unexpected tag element 6525 err = decoder.Decoder.Skip() 6526 if err != nil { 6527 return err 6528 } 6529 6530 } 6531 decoder = originalDecoder 6532 } 6533 *v = sv 6534 return nil 6535} 6536 6537func awsRestxml_deserializeDocumentActivityMetrics(v **types.ActivityMetrics, decoder smithyxml.NodeDecoder) error { 6538 if v == nil { 6539 return fmt.Errorf("unexpected nil of type %T", v) 6540 } 6541 var sv *types.ActivityMetrics 6542 if *v == nil { 6543 sv = &types.ActivityMetrics{} 6544 } else { 6545 sv = *v 6546 } 6547 6548 for { 6549 t, done, err := decoder.Token() 6550 if err != nil { 6551 return err 6552 } 6553 if done { 6554 break 6555 } 6556 originalDecoder := decoder 6557 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6558 switch { 6559 case strings.EqualFold("IsEnabled", t.Name.Local): 6560 val, err := decoder.Value() 6561 if err != nil { 6562 return err 6563 } 6564 if val == nil { 6565 break 6566 } 6567 { 6568 xtv, err := strconv.ParseBool(string(val)) 6569 if err != nil { 6570 return fmt.Errorf("expected IsEnabled to be of type *bool, got %T instead", val) 6571 } 6572 sv.IsEnabled = xtv 6573 } 6574 6575 default: 6576 // Do nothing and ignore the unexpected tag element 6577 err = decoder.Decoder.Skip() 6578 if err != nil { 6579 return err 6580 } 6581 6582 } 6583 decoder = originalDecoder 6584 } 6585 *v = sv 6586 return nil 6587} 6588 6589func awsRestxml_deserializeDocumentAwsLambdaTransformation(v **types.AwsLambdaTransformation, decoder smithyxml.NodeDecoder) error { 6590 if v == nil { 6591 return fmt.Errorf("unexpected nil of type %T", v) 6592 } 6593 var sv *types.AwsLambdaTransformation 6594 if *v == nil { 6595 sv = &types.AwsLambdaTransformation{} 6596 } else { 6597 sv = *v 6598 } 6599 6600 for { 6601 t, done, err := decoder.Token() 6602 if err != nil { 6603 return err 6604 } 6605 if done { 6606 break 6607 } 6608 originalDecoder := decoder 6609 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6610 switch { 6611 case strings.EqualFold("FunctionArn", t.Name.Local): 6612 val, err := decoder.Value() 6613 if err != nil { 6614 return err 6615 } 6616 if val == nil { 6617 break 6618 } 6619 { 6620 xtv := string(val) 6621 sv.FunctionArn = ptr.String(xtv) 6622 } 6623 6624 case strings.EqualFold("FunctionPayload", t.Name.Local): 6625 val, err := decoder.Value() 6626 if err != nil { 6627 return err 6628 } 6629 if val == nil { 6630 break 6631 } 6632 { 6633 xtv := string(val) 6634 sv.FunctionPayload = ptr.String(xtv) 6635 } 6636 6637 default: 6638 // Do nothing and ignore the unexpected tag element 6639 err = decoder.Decoder.Skip() 6640 if err != nil { 6641 return err 6642 } 6643 6644 } 6645 decoder = originalDecoder 6646 } 6647 *v = sv 6648 return nil 6649} 6650 6651func awsRestxml_deserializeDocumentBadRequestException(v **types.BadRequestException, decoder smithyxml.NodeDecoder) error { 6652 if v == nil { 6653 return fmt.Errorf("unexpected nil of type %T", v) 6654 } 6655 var sv *types.BadRequestException 6656 if *v == nil { 6657 sv = &types.BadRequestException{} 6658 } else { 6659 sv = *v 6660 } 6661 6662 for { 6663 t, done, err := decoder.Token() 6664 if err != nil { 6665 return err 6666 } 6667 if done { 6668 break 6669 } 6670 originalDecoder := decoder 6671 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6672 switch { 6673 case strings.EqualFold("Message", t.Name.Local): 6674 val, err := decoder.Value() 6675 if err != nil { 6676 return err 6677 } 6678 if val == nil { 6679 break 6680 } 6681 { 6682 xtv := string(val) 6683 sv.Message = ptr.String(xtv) 6684 } 6685 6686 default: 6687 // Do nothing and ignore the unexpected tag element 6688 err = decoder.Decoder.Skip() 6689 if err != nil { 6690 return err 6691 } 6692 6693 } 6694 decoder = originalDecoder 6695 } 6696 *v = sv 6697 return nil 6698} 6699 6700func awsRestxml_deserializeDocumentBucketAlreadyExists(v **types.BucketAlreadyExists, decoder smithyxml.NodeDecoder) error { 6701 if v == nil { 6702 return fmt.Errorf("unexpected nil of type %T", v) 6703 } 6704 var sv *types.BucketAlreadyExists 6705 if *v == nil { 6706 sv = &types.BucketAlreadyExists{} 6707 } else { 6708 sv = *v 6709 } 6710 6711 for { 6712 t, done, err := decoder.Token() 6713 if err != nil { 6714 return err 6715 } 6716 if done { 6717 break 6718 } 6719 originalDecoder := decoder 6720 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6721 switch { 6722 default: 6723 // Do nothing and ignore the unexpected tag element 6724 err = decoder.Decoder.Skip() 6725 if err != nil { 6726 return err 6727 } 6728 6729 } 6730 decoder = originalDecoder 6731 } 6732 *v = sv 6733 return nil 6734} 6735 6736func awsRestxml_deserializeDocumentBucketAlreadyOwnedByYou(v **types.BucketAlreadyOwnedByYou, decoder smithyxml.NodeDecoder) error { 6737 if v == nil { 6738 return fmt.Errorf("unexpected nil of type %T", v) 6739 } 6740 var sv *types.BucketAlreadyOwnedByYou 6741 if *v == nil { 6742 sv = &types.BucketAlreadyOwnedByYou{} 6743 } else { 6744 sv = *v 6745 } 6746 6747 for { 6748 t, done, err := decoder.Token() 6749 if err != nil { 6750 return err 6751 } 6752 if done { 6753 break 6754 } 6755 originalDecoder := decoder 6756 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6757 switch { 6758 default: 6759 // Do nothing and ignore the unexpected tag element 6760 err = decoder.Decoder.Skip() 6761 if err != nil { 6762 return err 6763 } 6764 6765 } 6766 decoder = originalDecoder 6767 } 6768 *v = sv 6769 return nil 6770} 6771 6772func awsRestxml_deserializeDocumentBucketLevel(v **types.BucketLevel, decoder smithyxml.NodeDecoder) error { 6773 if v == nil { 6774 return fmt.Errorf("unexpected nil of type %T", v) 6775 } 6776 var sv *types.BucketLevel 6777 if *v == nil { 6778 sv = &types.BucketLevel{} 6779 } else { 6780 sv = *v 6781 } 6782 6783 for { 6784 t, done, err := decoder.Token() 6785 if err != nil { 6786 return err 6787 } 6788 if done { 6789 break 6790 } 6791 originalDecoder := decoder 6792 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6793 switch { 6794 case strings.EqualFold("ActivityMetrics", t.Name.Local): 6795 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6796 if err := awsRestxml_deserializeDocumentActivityMetrics(&sv.ActivityMetrics, nodeDecoder); err != nil { 6797 return err 6798 } 6799 6800 case strings.EqualFold("PrefixLevel", t.Name.Local): 6801 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6802 if err := awsRestxml_deserializeDocumentPrefixLevel(&sv.PrefixLevel, nodeDecoder); err != nil { 6803 return err 6804 } 6805 6806 default: 6807 // Do nothing and ignore the unexpected tag element 6808 err = decoder.Decoder.Skip() 6809 if err != nil { 6810 return err 6811 } 6812 6813 } 6814 decoder = originalDecoder 6815 } 6816 *v = sv 6817 return nil 6818} 6819 6820func awsRestxml_deserializeDocumentBuckets(v *[]string, decoder smithyxml.NodeDecoder) error { 6821 if v == nil { 6822 return fmt.Errorf("unexpected nil of type %T", v) 6823 } 6824 var sv []string 6825 if *v == nil { 6826 sv = make([]string, 0) 6827 } else { 6828 sv = *v 6829 } 6830 6831 originalDecoder := decoder 6832 for { 6833 t, done, err := decoder.Token() 6834 if err != nil { 6835 return err 6836 } 6837 if done { 6838 break 6839 } 6840 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6841 decoder = memberDecoder 6842 switch { 6843 case strings.EqualFold("Arn", t.Name.Local): 6844 var col string 6845 val, err := decoder.Value() 6846 if err != nil { 6847 return err 6848 } 6849 if val == nil { 6850 break 6851 } 6852 { 6853 xtv := string(val) 6854 col = xtv 6855 } 6856 sv = append(sv, col) 6857 6858 default: 6859 err = decoder.Decoder.Skip() 6860 if err != nil { 6861 return err 6862 } 6863 6864 } 6865 decoder = originalDecoder 6866 } 6867 *v = sv 6868 return nil 6869} 6870 6871func awsRestxml_deserializeDocumentBucketsUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 6872 var sv []string 6873 if *v == nil { 6874 sv = make([]string, 0) 6875 } else { 6876 sv = *v 6877 } 6878 6879 switch { 6880 default: 6881 var mv string 6882 t := decoder.StartEl 6883 _ = t 6884 val, err := decoder.Value() 6885 if err != nil { 6886 return err 6887 } 6888 if val == nil { 6889 break 6890 } 6891 { 6892 xtv := string(val) 6893 mv = xtv 6894 } 6895 sv = append(sv, mv) 6896 } 6897 *v = sv 6898 return nil 6899} 6900func awsRestxml_deserializeDocumentExclude(v **types.Exclude, decoder smithyxml.NodeDecoder) error { 6901 if v == nil { 6902 return fmt.Errorf("unexpected nil of type %T", v) 6903 } 6904 var sv *types.Exclude 6905 if *v == nil { 6906 sv = &types.Exclude{} 6907 } else { 6908 sv = *v 6909 } 6910 6911 for { 6912 t, done, err := decoder.Token() 6913 if err != nil { 6914 return err 6915 } 6916 if done { 6917 break 6918 } 6919 originalDecoder := decoder 6920 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6921 switch { 6922 case strings.EqualFold("Buckets", t.Name.Local): 6923 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6924 if err := awsRestxml_deserializeDocumentBuckets(&sv.Buckets, nodeDecoder); err != nil { 6925 return err 6926 } 6927 6928 case strings.EqualFold("Regions", t.Name.Local): 6929 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6930 if err := awsRestxml_deserializeDocumentRegions(&sv.Regions, nodeDecoder); err != nil { 6931 return err 6932 } 6933 6934 default: 6935 // Do nothing and ignore the unexpected tag element 6936 err = decoder.Decoder.Skip() 6937 if err != nil { 6938 return err 6939 } 6940 6941 } 6942 decoder = originalDecoder 6943 } 6944 *v = sv 6945 return nil 6946} 6947 6948func awsRestxml_deserializeDocumentIdempotencyException(v **types.IdempotencyException, decoder smithyxml.NodeDecoder) error { 6949 if v == nil { 6950 return fmt.Errorf("unexpected nil of type %T", v) 6951 } 6952 var sv *types.IdempotencyException 6953 if *v == nil { 6954 sv = &types.IdempotencyException{} 6955 } else { 6956 sv = *v 6957 } 6958 6959 for { 6960 t, done, err := decoder.Token() 6961 if err != nil { 6962 return err 6963 } 6964 if done { 6965 break 6966 } 6967 originalDecoder := decoder 6968 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6969 switch { 6970 case strings.EqualFold("Message", t.Name.Local): 6971 val, err := decoder.Value() 6972 if err != nil { 6973 return err 6974 } 6975 if val == nil { 6976 break 6977 } 6978 { 6979 xtv := string(val) 6980 sv.Message = ptr.String(xtv) 6981 } 6982 6983 default: 6984 // Do nothing and ignore the unexpected tag element 6985 err = decoder.Decoder.Skip() 6986 if err != nil { 6987 return err 6988 } 6989 6990 } 6991 decoder = originalDecoder 6992 } 6993 *v = sv 6994 return nil 6995} 6996 6997func awsRestxml_deserializeDocumentInclude(v **types.Include, decoder smithyxml.NodeDecoder) error { 6998 if v == nil { 6999 return fmt.Errorf("unexpected nil of type %T", v) 7000 } 7001 var sv *types.Include 7002 if *v == nil { 7003 sv = &types.Include{} 7004 } else { 7005 sv = *v 7006 } 7007 7008 for { 7009 t, done, err := decoder.Token() 7010 if err != nil { 7011 return err 7012 } 7013 if done { 7014 break 7015 } 7016 originalDecoder := decoder 7017 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7018 switch { 7019 case strings.EqualFold("Buckets", t.Name.Local): 7020 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7021 if err := awsRestxml_deserializeDocumentBuckets(&sv.Buckets, nodeDecoder); err != nil { 7022 return err 7023 } 7024 7025 case strings.EqualFold("Regions", t.Name.Local): 7026 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7027 if err := awsRestxml_deserializeDocumentRegions(&sv.Regions, nodeDecoder); err != nil { 7028 return err 7029 } 7030 7031 default: 7032 // Do nothing and ignore the unexpected tag element 7033 err = decoder.Decoder.Skip() 7034 if err != nil { 7035 return err 7036 } 7037 7038 } 7039 decoder = originalDecoder 7040 } 7041 *v = sv 7042 return nil 7043} 7044 7045func awsRestxml_deserializeDocumentInternalServiceException(v **types.InternalServiceException, decoder smithyxml.NodeDecoder) error { 7046 if v == nil { 7047 return fmt.Errorf("unexpected nil of type %T", v) 7048 } 7049 var sv *types.InternalServiceException 7050 if *v == nil { 7051 sv = &types.InternalServiceException{} 7052 } else { 7053 sv = *v 7054 } 7055 7056 for { 7057 t, done, err := decoder.Token() 7058 if err != nil { 7059 return err 7060 } 7061 if done { 7062 break 7063 } 7064 originalDecoder := decoder 7065 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7066 switch { 7067 case strings.EqualFold("Message", t.Name.Local): 7068 val, err := decoder.Value() 7069 if err != nil { 7070 return err 7071 } 7072 if val == nil { 7073 break 7074 } 7075 { 7076 xtv := string(val) 7077 sv.Message = ptr.String(xtv) 7078 } 7079 7080 default: 7081 // Do nothing and ignore the unexpected tag element 7082 err = decoder.Decoder.Skip() 7083 if err != nil { 7084 return err 7085 } 7086 7087 } 7088 decoder = originalDecoder 7089 } 7090 *v = sv 7091 return nil 7092} 7093 7094func awsRestxml_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, decoder smithyxml.NodeDecoder) error { 7095 if v == nil { 7096 return fmt.Errorf("unexpected nil of type %T", v) 7097 } 7098 var sv *types.InvalidNextTokenException 7099 if *v == nil { 7100 sv = &types.InvalidNextTokenException{} 7101 } else { 7102 sv = *v 7103 } 7104 7105 for { 7106 t, done, err := decoder.Token() 7107 if err != nil { 7108 return err 7109 } 7110 if done { 7111 break 7112 } 7113 originalDecoder := decoder 7114 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7115 switch { 7116 case strings.EqualFold("Message", t.Name.Local): 7117 val, err := decoder.Value() 7118 if err != nil { 7119 return err 7120 } 7121 if val == nil { 7122 break 7123 } 7124 { 7125 xtv := string(val) 7126 sv.Message = ptr.String(xtv) 7127 } 7128 7129 default: 7130 // Do nothing and ignore the unexpected tag element 7131 err = decoder.Decoder.Skip() 7132 if err != nil { 7133 return err 7134 } 7135 7136 } 7137 decoder = originalDecoder 7138 } 7139 *v = sv 7140 return nil 7141} 7142 7143func awsRestxml_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, decoder smithyxml.NodeDecoder) error { 7144 if v == nil { 7145 return fmt.Errorf("unexpected nil of type %T", v) 7146 } 7147 var sv *types.InvalidRequestException 7148 if *v == nil { 7149 sv = &types.InvalidRequestException{} 7150 } else { 7151 sv = *v 7152 } 7153 7154 for { 7155 t, done, err := decoder.Token() 7156 if err != nil { 7157 return err 7158 } 7159 if done { 7160 break 7161 } 7162 originalDecoder := decoder 7163 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7164 switch { 7165 case strings.EqualFold("Message", t.Name.Local): 7166 val, err := decoder.Value() 7167 if err != nil { 7168 return err 7169 } 7170 if val == nil { 7171 break 7172 } 7173 { 7174 xtv := string(val) 7175 sv.Message = ptr.String(xtv) 7176 } 7177 7178 default: 7179 // Do nothing and ignore the unexpected tag element 7180 err = decoder.Decoder.Skip() 7181 if err != nil { 7182 return err 7183 } 7184 7185 } 7186 decoder = originalDecoder 7187 } 7188 *v = sv 7189 return nil 7190} 7191 7192func awsRestxml_deserializeDocumentJobDescriptor(v **types.JobDescriptor, decoder smithyxml.NodeDecoder) error { 7193 if v == nil { 7194 return fmt.Errorf("unexpected nil of type %T", v) 7195 } 7196 var sv *types.JobDescriptor 7197 if *v == nil { 7198 sv = &types.JobDescriptor{} 7199 } else { 7200 sv = *v 7201 } 7202 7203 for { 7204 t, done, err := decoder.Token() 7205 if err != nil { 7206 return err 7207 } 7208 if done { 7209 break 7210 } 7211 originalDecoder := decoder 7212 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7213 switch { 7214 case strings.EqualFold("ConfirmationRequired", t.Name.Local): 7215 val, err := decoder.Value() 7216 if err != nil { 7217 return err 7218 } 7219 if val == nil { 7220 break 7221 } 7222 { 7223 xtv, err := strconv.ParseBool(string(val)) 7224 if err != nil { 7225 return fmt.Errorf("expected ConfirmationRequired to be of type *bool, got %T instead", val) 7226 } 7227 sv.ConfirmationRequired = xtv 7228 } 7229 7230 case strings.EqualFold("CreationTime", t.Name.Local): 7231 val, err := decoder.Value() 7232 if err != nil { 7233 return err 7234 } 7235 if val == nil { 7236 break 7237 } 7238 { 7239 xtv := string(val) 7240 t, err := smithytime.ParseDateTime(xtv) 7241 if err != nil { 7242 return err 7243 } 7244 sv.CreationTime = ptr.Time(t) 7245 } 7246 7247 case strings.EqualFold("Description", t.Name.Local): 7248 val, err := decoder.Value() 7249 if err != nil { 7250 return err 7251 } 7252 if val == nil { 7253 break 7254 } 7255 { 7256 xtv := string(val) 7257 sv.Description = ptr.String(xtv) 7258 } 7259 7260 case strings.EqualFold("FailureReasons", t.Name.Local): 7261 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7262 if err := awsRestxml_deserializeDocumentJobFailureList(&sv.FailureReasons, nodeDecoder); err != nil { 7263 return err 7264 } 7265 7266 case strings.EqualFold("JobArn", t.Name.Local): 7267 val, err := decoder.Value() 7268 if err != nil { 7269 return err 7270 } 7271 if val == nil { 7272 break 7273 } 7274 { 7275 xtv := string(val) 7276 sv.JobArn = ptr.String(xtv) 7277 } 7278 7279 case strings.EqualFold("JobId", t.Name.Local): 7280 val, err := decoder.Value() 7281 if err != nil { 7282 return err 7283 } 7284 if val == nil { 7285 break 7286 } 7287 { 7288 xtv := string(val) 7289 sv.JobId = ptr.String(xtv) 7290 } 7291 7292 case strings.EqualFold("Manifest", t.Name.Local): 7293 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7294 if err := awsRestxml_deserializeDocumentJobManifest(&sv.Manifest, nodeDecoder); err != nil { 7295 return err 7296 } 7297 7298 case strings.EqualFold("Operation", t.Name.Local): 7299 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7300 if err := awsRestxml_deserializeDocumentJobOperation(&sv.Operation, nodeDecoder); err != nil { 7301 return err 7302 } 7303 7304 case strings.EqualFold("Priority", t.Name.Local): 7305 val, err := decoder.Value() 7306 if err != nil { 7307 return err 7308 } 7309 if val == nil { 7310 break 7311 } 7312 { 7313 xtv := string(val) 7314 i64, err := strconv.ParseInt(xtv, 10, 64) 7315 if err != nil { 7316 return err 7317 } 7318 sv.Priority = int32(i64) 7319 } 7320 7321 case strings.EqualFold("ProgressSummary", t.Name.Local): 7322 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7323 if err := awsRestxml_deserializeDocumentJobProgressSummary(&sv.ProgressSummary, nodeDecoder); err != nil { 7324 return err 7325 } 7326 7327 case strings.EqualFold("Report", t.Name.Local): 7328 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7329 if err := awsRestxml_deserializeDocumentJobReport(&sv.Report, nodeDecoder); err != nil { 7330 return err 7331 } 7332 7333 case strings.EqualFold("RoleArn", t.Name.Local): 7334 val, err := decoder.Value() 7335 if err != nil { 7336 return err 7337 } 7338 if val == nil { 7339 break 7340 } 7341 { 7342 xtv := string(val) 7343 sv.RoleArn = ptr.String(xtv) 7344 } 7345 7346 case strings.EqualFold("Status", t.Name.Local): 7347 val, err := decoder.Value() 7348 if err != nil { 7349 return err 7350 } 7351 if val == nil { 7352 break 7353 } 7354 { 7355 xtv := string(val) 7356 sv.Status = types.JobStatus(xtv) 7357 } 7358 7359 case strings.EqualFold("StatusUpdateReason", t.Name.Local): 7360 val, err := decoder.Value() 7361 if err != nil { 7362 return err 7363 } 7364 if val == nil { 7365 break 7366 } 7367 { 7368 xtv := string(val) 7369 sv.StatusUpdateReason = ptr.String(xtv) 7370 } 7371 7372 case strings.EqualFold("SuspendedCause", t.Name.Local): 7373 val, err := decoder.Value() 7374 if err != nil { 7375 return err 7376 } 7377 if val == nil { 7378 break 7379 } 7380 { 7381 xtv := string(val) 7382 sv.SuspendedCause = ptr.String(xtv) 7383 } 7384 7385 case strings.EqualFold("SuspendedDate", t.Name.Local): 7386 val, err := decoder.Value() 7387 if err != nil { 7388 return err 7389 } 7390 if val == nil { 7391 break 7392 } 7393 { 7394 xtv := string(val) 7395 t, err := smithytime.ParseDateTime(xtv) 7396 if err != nil { 7397 return err 7398 } 7399 sv.SuspendedDate = ptr.Time(t) 7400 } 7401 7402 case strings.EqualFold("TerminationDate", t.Name.Local): 7403 val, err := decoder.Value() 7404 if err != nil { 7405 return err 7406 } 7407 if val == nil { 7408 break 7409 } 7410 { 7411 xtv := string(val) 7412 t, err := smithytime.ParseDateTime(xtv) 7413 if err != nil { 7414 return err 7415 } 7416 sv.TerminationDate = ptr.Time(t) 7417 } 7418 7419 default: 7420 // Do nothing and ignore the unexpected tag element 7421 err = decoder.Decoder.Skip() 7422 if err != nil { 7423 return err 7424 } 7425 7426 } 7427 decoder = originalDecoder 7428 } 7429 *v = sv 7430 return nil 7431} 7432 7433func awsRestxml_deserializeDocumentJobFailure(v **types.JobFailure, decoder smithyxml.NodeDecoder) error { 7434 if v == nil { 7435 return fmt.Errorf("unexpected nil of type %T", v) 7436 } 7437 var sv *types.JobFailure 7438 if *v == nil { 7439 sv = &types.JobFailure{} 7440 } else { 7441 sv = *v 7442 } 7443 7444 for { 7445 t, done, err := decoder.Token() 7446 if err != nil { 7447 return err 7448 } 7449 if done { 7450 break 7451 } 7452 originalDecoder := decoder 7453 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7454 switch { 7455 case strings.EqualFold("FailureCode", t.Name.Local): 7456 val, err := decoder.Value() 7457 if err != nil { 7458 return err 7459 } 7460 if val == nil { 7461 break 7462 } 7463 { 7464 xtv := string(val) 7465 sv.FailureCode = ptr.String(xtv) 7466 } 7467 7468 case strings.EqualFold("FailureReason", t.Name.Local): 7469 val, err := decoder.Value() 7470 if err != nil { 7471 return err 7472 } 7473 if val == nil { 7474 break 7475 } 7476 { 7477 xtv := string(val) 7478 sv.FailureReason = ptr.String(xtv) 7479 } 7480 7481 default: 7482 // Do nothing and ignore the unexpected tag element 7483 err = decoder.Decoder.Skip() 7484 if err != nil { 7485 return err 7486 } 7487 7488 } 7489 decoder = originalDecoder 7490 } 7491 *v = sv 7492 return nil 7493} 7494 7495func awsRestxml_deserializeDocumentJobFailureList(v *[]types.JobFailure, decoder smithyxml.NodeDecoder) error { 7496 if v == nil { 7497 return fmt.Errorf("unexpected nil of type %T", v) 7498 } 7499 var sv []types.JobFailure 7500 if *v == nil { 7501 sv = make([]types.JobFailure, 0) 7502 } else { 7503 sv = *v 7504 } 7505 7506 originalDecoder := decoder 7507 for { 7508 t, done, err := decoder.Token() 7509 if err != nil { 7510 return err 7511 } 7512 if done { 7513 break 7514 } 7515 switch { 7516 case strings.EqualFold("member", t.Name.Local): 7517 var col types.JobFailure 7518 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7519 destAddr := &col 7520 if err := awsRestxml_deserializeDocumentJobFailure(&destAddr, nodeDecoder); err != nil { 7521 return err 7522 } 7523 col = *destAddr 7524 sv = append(sv, col) 7525 7526 default: 7527 err = decoder.Decoder.Skip() 7528 if err != nil { 7529 return err 7530 } 7531 7532 } 7533 decoder = originalDecoder 7534 } 7535 *v = sv 7536 return nil 7537} 7538 7539func awsRestxml_deserializeDocumentJobFailureListUnwrapped(v *[]types.JobFailure, decoder smithyxml.NodeDecoder) error { 7540 var sv []types.JobFailure 7541 if *v == nil { 7542 sv = make([]types.JobFailure, 0) 7543 } else { 7544 sv = *v 7545 } 7546 7547 switch { 7548 default: 7549 var mv types.JobFailure 7550 t := decoder.StartEl 7551 _ = t 7552 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7553 destAddr := &mv 7554 if err := awsRestxml_deserializeDocumentJobFailure(&destAddr, nodeDecoder); err != nil { 7555 return err 7556 } 7557 mv = *destAddr 7558 sv = append(sv, mv) 7559 } 7560 *v = sv 7561 return nil 7562} 7563func awsRestxml_deserializeDocumentJobListDescriptor(v **types.JobListDescriptor, decoder smithyxml.NodeDecoder) error { 7564 if v == nil { 7565 return fmt.Errorf("unexpected nil of type %T", v) 7566 } 7567 var sv *types.JobListDescriptor 7568 if *v == nil { 7569 sv = &types.JobListDescriptor{} 7570 } else { 7571 sv = *v 7572 } 7573 7574 for { 7575 t, done, err := decoder.Token() 7576 if err != nil { 7577 return err 7578 } 7579 if done { 7580 break 7581 } 7582 originalDecoder := decoder 7583 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7584 switch { 7585 case strings.EqualFold("CreationTime", t.Name.Local): 7586 val, err := decoder.Value() 7587 if err != nil { 7588 return err 7589 } 7590 if val == nil { 7591 break 7592 } 7593 { 7594 xtv := string(val) 7595 t, err := smithytime.ParseDateTime(xtv) 7596 if err != nil { 7597 return err 7598 } 7599 sv.CreationTime = ptr.Time(t) 7600 } 7601 7602 case strings.EqualFold("Description", t.Name.Local): 7603 val, err := decoder.Value() 7604 if err != nil { 7605 return err 7606 } 7607 if val == nil { 7608 break 7609 } 7610 { 7611 xtv := string(val) 7612 sv.Description = ptr.String(xtv) 7613 } 7614 7615 case strings.EqualFold("JobId", t.Name.Local): 7616 val, err := decoder.Value() 7617 if err != nil { 7618 return err 7619 } 7620 if val == nil { 7621 break 7622 } 7623 { 7624 xtv := string(val) 7625 sv.JobId = ptr.String(xtv) 7626 } 7627 7628 case strings.EqualFold("Operation", t.Name.Local): 7629 val, err := decoder.Value() 7630 if err != nil { 7631 return err 7632 } 7633 if val == nil { 7634 break 7635 } 7636 { 7637 xtv := string(val) 7638 sv.Operation = types.OperationName(xtv) 7639 } 7640 7641 case strings.EqualFold("Priority", t.Name.Local): 7642 val, err := decoder.Value() 7643 if err != nil { 7644 return err 7645 } 7646 if val == nil { 7647 break 7648 } 7649 { 7650 xtv := string(val) 7651 i64, err := strconv.ParseInt(xtv, 10, 64) 7652 if err != nil { 7653 return err 7654 } 7655 sv.Priority = int32(i64) 7656 } 7657 7658 case strings.EqualFold("ProgressSummary", t.Name.Local): 7659 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7660 if err := awsRestxml_deserializeDocumentJobProgressSummary(&sv.ProgressSummary, nodeDecoder); err != nil { 7661 return err 7662 } 7663 7664 case strings.EqualFold("Status", t.Name.Local): 7665 val, err := decoder.Value() 7666 if err != nil { 7667 return err 7668 } 7669 if val == nil { 7670 break 7671 } 7672 { 7673 xtv := string(val) 7674 sv.Status = types.JobStatus(xtv) 7675 } 7676 7677 case strings.EqualFold("TerminationDate", t.Name.Local): 7678 val, err := decoder.Value() 7679 if err != nil { 7680 return err 7681 } 7682 if val == nil { 7683 break 7684 } 7685 { 7686 xtv := string(val) 7687 t, err := smithytime.ParseDateTime(xtv) 7688 if err != nil { 7689 return err 7690 } 7691 sv.TerminationDate = ptr.Time(t) 7692 } 7693 7694 default: 7695 // Do nothing and ignore the unexpected tag element 7696 err = decoder.Decoder.Skip() 7697 if err != nil { 7698 return err 7699 } 7700 7701 } 7702 decoder = originalDecoder 7703 } 7704 *v = sv 7705 return nil 7706} 7707 7708func awsRestxml_deserializeDocumentJobListDescriptorList(v *[]types.JobListDescriptor, decoder smithyxml.NodeDecoder) error { 7709 if v == nil { 7710 return fmt.Errorf("unexpected nil of type %T", v) 7711 } 7712 var sv []types.JobListDescriptor 7713 if *v == nil { 7714 sv = make([]types.JobListDescriptor, 0) 7715 } else { 7716 sv = *v 7717 } 7718 7719 originalDecoder := decoder 7720 for { 7721 t, done, err := decoder.Token() 7722 if err != nil { 7723 return err 7724 } 7725 if done { 7726 break 7727 } 7728 switch { 7729 case strings.EqualFold("member", t.Name.Local): 7730 var col types.JobListDescriptor 7731 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7732 destAddr := &col 7733 if err := awsRestxml_deserializeDocumentJobListDescriptor(&destAddr, nodeDecoder); err != nil { 7734 return err 7735 } 7736 col = *destAddr 7737 sv = append(sv, col) 7738 7739 default: 7740 err = decoder.Decoder.Skip() 7741 if err != nil { 7742 return err 7743 } 7744 7745 } 7746 decoder = originalDecoder 7747 } 7748 *v = sv 7749 return nil 7750} 7751 7752func awsRestxml_deserializeDocumentJobListDescriptorListUnwrapped(v *[]types.JobListDescriptor, decoder smithyxml.NodeDecoder) error { 7753 var sv []types.JobListDescriptor 7754 if *v == nil { 7755 sv = make([]types.JobListDescriptor, 0) 7756 } else { 7757 sv = *v 7758 } 7759 7760 switch { 7761 default: 7762 var mv types.JobListDescriptor 7763 t := decoder.StartEl 7764 _ = t 7765 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7766 destAddr := &mv 7767 if err := awsRestxml_deserializeDocumentJobListDescriptor(&destAddr, nodeDecoder); err != nil { 7768 return err 7769 } 7770 mv = *destAddr 7771 sv = append(sv, mv) 7772 } 7773 *v = sv 7774 return nil 7775} 7776func awsRestxml_deserializeDocumentJobManifest(v **types.JobManifest, decoder smithyxml.NodeDecoder) error { 7777 if v == nil { 7778 return fmt.Errorf("unexpected nil of type %T", v) 7779 } 7780 var sv *types.JobManifest 7781 if *v == nil { 7782 sv = &types.JobManifest{} 7783 } else { 7784 sv = *v 7785 } 7786 7787 for { 7788 t, done, err := decoder.Token() 7789 if err != nil { 7790 return err 7791 } 7792 if done { 7793 break 7794 } 7795 originalDecoder := decoder 7796 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7797 switch { 7798 case strings.EqualFold("Location", t.Name.Local): 7799 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7800 if err := awsRestxml_deserializeDocumentJobManifestLocation(&sv.Location, nodeDecoder); err != nil { 7801 return err 7802 } 7803 7804 case strings.EqualFold("Spec", t.Name.Local): 7805 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7806 if err := awsRestxml_deserializeDocumentJobManifestSpec(&sv.Spec, nodeDecoder); err != nil { 7807 return err 7808 } 7809 7810 default: 7811 // Do nothing and ignore the unexpected tag element 7812 err = decoder.Decoder.Skip() 7813 if err != nil { 7814 return err 7815 } 7816 7817 } 7818 decoder = originalDecoder 7819 } 7820 *v = sv 7821 return nil 7822} 7823 7824func awsRestxml_deserializeDocumentJobManifestFieldList(v *[]types.JobManifestFieldName, decoder smithyxml.NodeDecoder) error { 7825 if v == nil { 7826 return fmt.Errorf("unexpected nil of type %T", v) 7827 } 7828 var sv []types.JobManifestFieldName 7829 if *v == nil { 7830 sv = make([]types.JobManifestFieldName, 0) 7831 } else { 7832 sv = *v 7833 } 7834 7835 originalDecoder := decoder 7836 for { 7837 t, done, err := decoder.Token() 7838 if err != nil { 7839 return err 7840 } 7841 if done { 7842 break 7843 } 7844 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7845 decoder = memberDecoder 7846 switch { 7847 case strings.EqualFold("member", t.Name.Local): 7848 var col types.JobManifestFieldName 7849 val, err := decoder.Value() 7850 if err != nil { 7851 return err 7852 } 7853 if val == nil { 7854 break 7855 } 7856 { 7857 xtv := string(val) 7858 col = types.JobManifestFieldName(xtv) 7859 } 7860 sv = append(sv, col) 7861 7862 default: 7863 err = decoder.Decoder.Skip() 7864 if err != nil { 7865 return err 7866 } 7867 7868 } 7869 decoder = originalDecoder 7870 } 7871 *v = sv 7872 return nil 7873} 7874 7875func awsRestxml_deserializeDocumentJobManifestFieldListUnwrapped(v *[]types.JobManifestFieldName, decoder smithyxml.NodeDecoder) error { 7876 var sv []types.JobManifestFieldName 7877 if *v == nil { 7878 sv = make([]types.JobManifestFieldName, 0) 7879 } else { 7880 sv = *v 7881 } 7882 7883 switch { 7884 default: 7885 var mv types.JobManifestFieldName 7886 t := decoder.StartEl 7887 _ = t 7888 val, err := decoder.Value() 7889 if err != nil { 7890 return err 7891 } 7892 if val == nil { 7893 break 7894 } 7895 { 7896 xtv := string(val) 7897 mv = types.JobManifestFieldName(xtv) 7898 } 7899 sv = append(sv, mv) 7900 } 7901 *v = sv 7902 return nil 7903} 7904func awsRestxml_deserializeDocumentJobManifestLocation(v **types.JobManifestLocation, decoder smithyxml.NodeDecoder) error { 7905 if v == nil { 7906 return fmt.Errorf("unexpected nil of type %T", v) 7907 } 7908 var sv *types.JobManifestLocation 7909 if *v == nil { 7910 sv = &types.JobManifestLocation{} 7911 } else { 7912 sv = *v 7913 } 7914 7915 for { 7916 t, done, err := decoder.Token() 7917 if err != nil { 7918 return err 7919 } 7920 if done { 7921 break 7922 } 7923 originalDecoder := decoder 7924 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7925 switch { 7926 case strings.EqualFold("ETag", t.Name.Local): 7927 val, err := decoder.Value() 7928 if err != nil { 7929 return err 7930 } 7931 if val == nil { 7932 break 7933 } 7934 { 7935 xtv := string(val) 7936 sv.ETag = ptr.String(xtv) 7937 } 7938 7939 case strings.EqualFold("ObjectArn", t.Name.Local): 7940 val, err := decoder.Value() 7941 if err != nil { 7942 return err 7943 } 7944 if val == nil { 7945 break 7946 } 7947 { 7948 xtv := string(val) 7949 sv.ObjectArn = ptr.String(xtv) 7950 } 7951 7952 case strings.EqualFold("ObjectVersionId", t.Name.Local): 7953 val, err := decoder.Value() 7954 if err != nil { 7955 return err 7956 } 7957 if val == nil { 7958 break 7959 } 7960 { 7961 xtv := string(val) 7962 sv.ObjectVersionId = ptr.String(xtv) 7963 } 7964 7965 default: 7966 // Do nothing and ignore the unexpected tag element 7967 err = decoder.Decoder.Skip() 7968 if err != nil { 7969 return err 7970 } 7971 7972 } 7973 decoder = originalDecoder 7974 } 7975 *v = sv 7976 return nil 7977} 7978 7979func awsRestxml_deserializeDocumentJobManifestSpec(v **types.JobManifestSpec, decoder smithyxml.NodeDecoder) error { 7980 if v == nil { 7981 return fmt.Errorf("unexpected nil of type %T", v) 7982 } 7983 var sv *types.JobManifestSpec 7984 if *v == nil { 7985 sv = &types.JobManifestSpec{} 7986 } else { 7987 sv = *v 7988 } 7989 7990 for { 7991 t, done, err := decoder.Token() 7992 if err != nil { 7993 return err 7994 } 7995 if done { 7996 break 7997 } 7998 originalDecoder := decoder 7999 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8000 switch { 8001 case strings.EqualFold("Fields", t.Name.Local): 8002 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8003 if err := awsRestxml_deserializeDocumentJobManifestFieldList(&sv.Fields, nodeDecoder); err != nil { 8004 return err 8005 } 8006 8007 case strings.EqualFold("Format", t.Name.Local): 8008 val, err := decoder.Value() 8009 if err != nil { 8010 return err 8011 } 8012 if val == nil { 8013 break 8014 } 8015 { 8016 xtv := string(val) 8017 sv.Format = types.JobManifestFormat(xtv) 8018 } 8019 8020 default: 8021 // Do nothing and ignore the unexpected tag element 8022 err = decoder.Decoder.Skip() 8023 if err != nil { 8024 return err 8025 } 8026 8027 } 8028 decoder = originalDecoder 8029 } 8030 *v = sv 8031 return nil 8032} 8033 8034func awsRestxml_deserializeDocumentJobOperation(v **types.JobOperation, decoder smithyxml.NodeDecoder) error { 8035 if v == nil { 8036 return fmt.Errorf("unexpected nil of type %T", v) 8037 } 8038 var sv *types.JobOperation 8039 if *v == nil { 8040 sv = &types.JobOperation{} 8041 } else { 8042 sv = *v 8043 } 8044 8045 for { 8046 t, done, err := decoder.Token() 8047 if err != nil { 8048 return err 8049 } 8050 if done { 8051 break 8052 } 8053 originalDecoder := decoder 8054 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8055 switch { 8056 case strings.EqualFold("LambdaInvoke", t.Name.Local): 8057 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8058 if err := awsRestxml_deserializeDocumentLambdaInvokeOperation(&sv.LambdaInvoke, nodeDecoder); err != nil { 8059 return err 8060 } 8061 8062 case strings.EqualFold("S3DeleteObjectTagging", t.Name.Local): 8063 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8064 if err := awsRestxml_deserializeDocumentS3DeleteObjectTaggingOperation(&sv.S3DeleteObjectTagging, nodeDecoder); err != nil { 8065 return err 8066 } 8067 8068 case strings.EqualFold("S3InitiateRestoreObject", t.Name.Local): 8069 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8070 if err := awsRestxml_deserializeDocumentS3InitiateRestoreObjectOperation(&sv.S3InitiateRestoreObject, nodeDecoder); err != nil { 8071 return err 8072 } 8073 8074 case strings.EqualFold("S3PutObjectAcl", t.Name.Local): 8075 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8076 if err := awsRestxml_deserializeDocumentS3SetObjectAclOperation(&sv.S3PutObjectAcl, nodeDecoder); err != nil { 8077 return err 8078 } 8079 8080 case strings.EqualFold("S3PutObjectCopy", t.Name.Local): 8081 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8082 if err := awsRestxml_deserializeDocumentS3CopyObjectOperation(&sv.S3PutObjectCopy, nodeDecoder); err != nil { 8083 return err 8084 } 8085 8086 case strings.EqualFold("S3PutObjectLegalHold", t.Name.Local): 8087 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8088 if err := awsRestxml_deserializeDocumentS3SetObjectLegalHoldOperation(&sv.S3PutObjectLegalHold, nodeDecoder); err != nil { 8089 return err 8090 } 8091 8092 case strings.EqualFold("S3PutObjectRetention", t.Name.Local): 8093 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8094 if err := awsRestxml_deserializeDocumentS3SetObjectRetentionOperation(&sv.S3PutObjectRetention, nodeDecoder); err != nil { 8095 return err 8096 } 8097 8098 case strings.EqualFold("S3PutObjectTagging", t.Name.Local): 8099 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8100 if err := awsRestxml_deserializeDocumentS3SetObjectTaggingOperation(&sv.S3PutObjectTagging, nodeDecoder); err != nil { 8101 return err 8102 } 8103 8104 default: 8105 // Do nothing and ignore the unexpected tag element 8106 err = decoder.Decoder.Skip() 8107 if err != nil { 8108 return err 8109 } 8110 8111 } 8112 decoder = originalDecoder 8113 } 8114 *v = sv 8115 return nil 8116} 8117 8118func awsRestxml_deserializeDocumentJobProgressSummary(v **types.JobProgressSummary, decoder smithyxml.NodeDecoder) error { 8119 if v == nil { 8120 return fmt.Errorf("unexpected nil of type %T", v) 8121 } 8122 var sv *types.JobProgressSummary 8123 if *v == nil { 8124 sv = &types.JobProgressSummary{} 8125 } else { 8126 sv = *v 8127 } 8128 8129 for { 8130 t, done, err := decoder.Token() 8131 if err != nil { 8132 return err 8133 } 8134 if done { 8135 break 8136 } 8137 originalDecoder := decoder 8138 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8139 switch { 8140 case strings.EqualFold("NumberOfTasksFailed", t.Name.Local): 8141 val, err := decoder.Value() 8142 if err != nil { 8143 return err 8144 } 8145 if val == nil { 8146 break 8147 } 8148 { 8149 xtv := string(val) 8150 i64, err := strconv.ParseInt(xtv, 10, 64) 8151 if err != nil { 8152 return err 8153 } 8154 sv.NumberOfTasksFailed = i64 8155 } 8156 8157 case strings.EqualFold("NumberOfTasksSucceeded", t.Name.Local): 8158 val, err := decoder.Value() 8159 if err != nil { 8160 return err 8161 } 8162 if val == nil { 8163 break 8164 } 8165 { 8166 xtv := string(val) 8167 i64, err := strconv.ParseInt(xtv, 10, 64) 8168 if err != nil { 8169 return err 8170 } 8171 sv.NumberOfTasksSucceeded = i64 8172 } 8173 8174 case strings.EqualFold("TotalNumberOfTasks", t.Name.Local): 8175 val, err := decoder.Value() 8176 if err != nil { 8177 return err 8178 } 8179 if val == nil { 8180 break 8181 } 8182 { 8183 xtv := string(val) 8184 i64, err := strconv.ParseInt(xtv, 10, 64) 8185 if err != nil { 8186 return err 8187 } 8188 sv.TotalNumberOfTasks = i64 8189 } 8190 8191 default: 8192 // Do nothing and ignore the unexpected tag element 8193 err = decoder.Decoder.Skip() 8194 if err != nil { 8195 return err 8196 } 8197 8198 } 8199 decoder = originalDecoder 8200 } 8201 *v = sv 8202 return nil 8203} 8204 8205func awsRestxml_deserializeDocumentJobReport(v **types.JobReport, decoder smithyxml.NodeDecoder) error { 8206 if v == nil { 8207 return fmt.Errorf("unexpected nil of type %T", v) 8208 } 8209 var sv *types.JobReport 8210 if *v == nil { 8211 sv = &types.JobReport{} 8212 } else { 8213 sv = *v 8214 } 8215 8216 for { 8217 t, done, err := decoder.Token() 8218 if err != nil { 8219 return err 8220 } 8221 if done { 8222 break 8223 } 8224 originalDecoder := decoder 8225 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8226 switch { 8227 case strings.EqualFold("Bucket", t.Name.Local): 8228 val, err := decoder.Value() 8229 if err != nil { 8230 return err 8231 } 8232 if val == nil { 8233 break 8234 } 8235 { 8236 xtv := string(val) 8237 sv.Bucket = ptr.String(xtv) 8238 } 8239 8240 case strings.EqualFold("Enabled", t.Name.Local): 8241 val, err := decoder.Value() 8242 if err != nil { 8243 return err 8244 } 8245 if val == nil { 8246 break 8247 } 8248 { 8249 xtv, err := strconv.ParseBool(string(val)) 8250 if err != nil { 8251 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 8252 } 8253 sv.Enabled = xtv 8254 } 8255 8256 case strings.EqualFold("Format", t.Name.Local): 8257 val, err := decoder.Value() 8258 if err != nil { 8259 return err 8260 } 8261 if val == nil { 8262 break 8263 } 8264 { 8265 xtv := string(val) 8266 sv.Format = types.JobReportFormat(xtv) 8267 } 8268 8269 case strings.EqualFold("Prefix", t.Name.Local): 8270 val, err := decoder.Value() 8271 if err != nil { 8272 return err 8273 } 8274 if val == nil { 8275 break 8276 } 8277 { 8278 xtv := string(val) 8279 sv.Prefix = ptr.String(xtv) 8280 } 8281 8282 case strings.EqualFold("ReportScope", t.Name.Local): 8283 val, err := decoder.Value() 8284 if err != nil { 8285 return err 8286 } 8287 if val == nil { 8288 break 8289 } 8290 { 8291 xtv := string(val) 8292 sv.ReportScope = types.JobReportScope(xtv) 8293 } 8294 8295 default: 8296 // Do nothing and ignore the unexpected tag element 8297 err = decoder.Decoder.Skip() 8298 if err != nil { 8299 return err 8300 } 8301 8302 } 8303 decoder = originalDecoder 8304 } 8305 *v = sv 8306 return nil 8307} 8308 8309func awsRestxml_deserializeDocumentJobStatusException(v **types.JobStatusException, decoder smithyxml.NodeDecoder) error { 8310 if v == nil { 8311 return fmt.Errorf("unexpected nil of type %T", v) 8312 } 8313 var sv *types.JobStatusException 8314 if *v == nil { 8315 sv = &types.JobStatusException{} 8316 } else { 8317 sv = *v 8318 } 8319 8320 for { 8321 t, done, err := decoder.Token() 8322 if err != nil { 8323 return err 8324 } 8325 if done { 8326 break 8327 } 8328 originalDecoder := decoder 8329 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8330 switch { 8331 case strings.EqualFold("Message", t.Name.Local): 8332 val, err := decoder.Value() 8333 if err != nil { 8334 return err 8335 } 8336 if val == nil { 8337 break 8338 } 8339 { 8340 xtv := string(val) 8341 sv.Message = ptr.String(xtv) 8342 } 8343 8344 default: 8345 // Do nothing and ignore the unexpected tag element 8346 err = decoder.Decoder.Skip() 8347 if err != nil { 8348 return err 8349 } 8350 8351 } 8352 decoder = originalDecoder 8353 } 8354 *v = sv 8355 return nil 8356} 8357 8358func awsRestxml_deserializeDocumentLambdaInvokeOperation(v **types.LambdaInvokeOperation, decoder smithyxml.NodeDecoder) error { 8359 if v == nil { 8360 return fmt.Errorf("unexpected nil of type %T", v) 8361 } 8362 var sv *types.LambdaInvokeOperation 8363 if *v == nil { 8364 sv = &types.LambdaInvokeOperation{} 8365 } else { 8366 sv = *v 8367 } 8368 8369 for { 8370 t, done, err := decoder.Token() 8371 if err != nil { 8372 return err 8373 } 8374 if done { 8375 break 8376 } 8377 originalDecoder := decoder 8378 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8379 switch { 8380 case strings.EqualFold("FunctionArn", t.Name.Local): 8381 val, err := decoder.Value() 8382 if err != nil { 8383 return err 8384 } 8385 if val == nil { 8386 break 8387 } 8388 { 8389 xtv := string(val) 8390 sv.FunctionArn = ptr.String(xtv) 8391 } 8392 8393 default: 8394 // Do nothing and ignore the unexpected tag element 8395 err = decoder.Decoder.Skip() 8396 if err != nil { 8397 return err 8398 } 8399 8400 } 8401 decoder = originalDecoder 8402 } 8403 *v = sv 8404 return nil 8405} 8406 8407func awsRestxml_deserializeDocumentLifecycleExpiration(v **types.LifecycleExpiration, decoder smithyxml.NodeDecoder) error { 8408 if v == nil { 8409 return fmt.Errorf("unexpected nil of type %T", v) 8410 } 8411 var sv *types.LifecycleExpiration 8412 if *v == nil { 8413 sv = &types.LifecycleExpiration{} 8414 } else { 8415 sv = *v 8416 } 8417 8418 for { 8419 t, done, err := decoder.Token() 8420 if err != nil { 8421 return err 8422 } 8423 if done { 8424 break 8425 } 8426 originalDecoder := decoder 8427 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8428 switch { 8429 case strings.EqualFold("Date", t.Name.Local): 8430 val, err := decoder.Value() 8431 if err != nil { 8432 return err 8433 } 8434 if val == nil { 8435 break 8436 } 8437 { 8438 xtv := string(val) 8439 t, err := smithytime.ParseDateTime(xtv) 8440 if err != nil { 8441 return err 8442 } 8443 sv.Date = ptr.Time(t) 8444 } 8445 8446 case strings.EqualFold("Days", t.Name.Local): 8447 val, err := decoder.Value() 8448 if err != nil { 8449 return err 8450 } 8451 if val == nil { 8452 break 8453 } 8454 { 8455 xtv := string(val) 8456 i64, err := strconv.ParseInt(xtv, 10, 64) 8457 if err != nil { 8458 return err 8459 } 8460 sv.Days = int32(i64) 8461 } 8462 8463 case strings.EqualFold("ExpiredObjectDeleteMarker", t.Name.Local): 8464 val, err := decoder.Value() 8465 if err != nil { 8466 return err 8467 } 8468 if val == nil { 8469 break 8470 } 8471 { 8472 xtv, err := strconv.ParseBool(string(val)) 8473 if err != nil { 8474 return fmt.Errorf("expected ExpiredObjectDeleteMarker to be of type *bool, got %T instead", val) 8475 } 8476 sv.ExpiredObjectDeleteMarker = xtv 8477 } 8478 8479 default: 8480 // Do nothing and ignore the unexpected tag element 8481 err = decoder.Decoder.Skip() 8482 if err != nil { 8483 return err 8484 } 8485 8486 } 8487 decoder = originalDecoder 8488 } 8489 *v = sv 8490 return nil 8491} 8492 8493func awsRestxml_deserializeDocumentLifecycleRule(v **types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 8494 if v == nil { 8495 return fmt.Errorf("unexpected nil of type %T", v) 8496 } 8497 var sv *types.LifecycleRule 8498 if *v == nil { 8499 sv = &types.LifecycleRule{} 8500 } else { 8501 sv = *v 8502 } 8503 8504 for { 8505 t, done, err := decoder.Token() 8506 if err != nil { 8507 return err 8508 } 8509 if done { 8510 break 8511 } 8512 originalDecoder := decoder 8513 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8514 switch { 8515 case strings.EqualFold("AbortIncompleteMultipartUpload", t.Name.Local): 8516 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8517 if err := awsRestxml_deserializeDocumentAbortIncompleteMultipartUpload(&sv.AbortIncompleteMultipartUpload, nodeDecoder); err != nil { 8518 return err 8519 } 8520 8521 case strings.EqualFold("Expiration", t.Name.Local): 8522 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8523 if err := awsRestxml_deserializeDocumentLifecycleExpiration(&sv.Expiration, nodeDecoder); err != nil { 8524 return err 8525 } 8526 8527 case strings.EqualFold("Filter", t.Name.Local): 8528 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8529 if err := awsRestxml_deserializeDocumentLifecycleRuleFilter(&sv.Filter, nodeDecoder); err != nil { 8530 return err 8531 } 8532 8533 case strings.EqualFold("ID", t.Name.Local): 8534 val, err := decoder.Value() 8535 if err != nil { 8536 return err 8537 } 8538 if val == nil { 8539 break 8540 } 8541 { 8542 xtv := string(val) 8543 sv.ID = ptr.String(xtv) 8544 } 8545 8546 case strings.EqualFold("NoncurrentVersionExpiration", t.Name.Local): 8547 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8548 if err := awsRestxml_deserializeDocumentNoncurrentVersionExpiration(&sv.NoncurrentVersionExpiration, nodeDecoder); err != nil { 8549 return err 8550 } 8551 8552 case strings.EqualFold("NoncurrentVersionTransitions", t.Name.Local): 8553 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8554 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransitionList(&sv.NoncurrentVersionTransitions, nodeDecoder); err != nil { 8555 return err 8556 } 8557 8558 case strings.EqualFold("Status", t.Name.Local): 8559 val, err := decoder.Value() 8560 if err != nil { 8561 return err 8562 } 8563 if val == nil { 8564 break 8565 } 8566 { 8567 xtv := string(val) 8568 sv.Status = types.ExpirationStatus(xtv) 8569 } 8570 8571 case strings.EqualFold("Transitions", t.Name.Local): 8572 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8573 if err := awsRestxml_deserializeDocumentTransitionList(&sv.Transitions, nodeDecoder); err != nil { 8574 return err 8575 } 8576 8577 default: 8578 // Do nothing and ignore the unexpected tag element 8579 err = decoder.Decoder.Skip() 8580 if err != nil { 8581 return err 8582 } 8583 8584 } 8585 decoder = originalDecoder 8586 } 8587 *v = sv 8588 return nil 8589} 8590 8591func awsRestxml_deserializeDocumentLifecycleRuleAndOperator(v **types.LifecycleRuleAndOperator, decoder smithyxml.NodeDecoder) error { 8592 if v == nil { 8593 return fmt.Errorf("unexpected nil of type %T", v) 8594 } 8595 var sv *types.LifecycleRuleAndOperator 8596 if *v == nil { 8597 sv = &types.LifecycleRuleAndOperator{} 8598 } else { 8599 sv = *v 8600 } 8601 8602 for { 8603 t, done, err := decoder.Token() 8604 if err != nil { 8605 return err 8606 } 8607 if done { 8608 break 8609 } 8610 originalDecoder := decoder 8611 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8612 switch { 8613 case strings.EqualFold("Prefix", t.Name.Local): 8614 val, err := decoder.Value() 8615 if err != nil { 8616 return err 8617 } 8618 if val == nil { 8619 break 8620 } 8621 { 8622 xtv := string(val) 8623 sv.Prefix = ptr.String(xtv) 8624 } 8625 8626 case strings.EqualFold("Tags", t.Name.Local): 8627 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8628 if err := awsRestxml_deserializeDocumentS3TagSet(&sv.Tags, nodeDecoder); err != nil { 8629 return err 8630 } 8631 8632 default: 8633 // Do nothing and ignore the unexpected tag element 8634 err = decoder.Decoder.Skip() 8635 if err != nil { 8636 return err 8637 } 8638 8639 } 8640 decoder = originalDecoder 8641 } 8642 *v = sv 8643 return nil 8644} 8645 8646func awsRestxml_deserializeDocumentLifecycleRuleFilter(v **types.LifecycleRuleFilter, decoder smithyxml.NodeDecoder) error { 8647 if v == nil { 8648 return fmt.Errorf("unexpected nil of type %T", v) 8649 } 8650 var sv *types.LifecycleRuleFilter 8651 if *v == nil { 8652 sv = &types.LifecycleRuleFilter{} 8653 } else { 8654 sv = *v 8655 } 8656 8657 for { 8658 t, done, err := decoder.Token() 8659 if err != nil { 8660 return err 8661 } 8662 if done { 8663 break 8664 } 8665 originalDecoder := decoder 8666 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8667 switch { 8668 case strings.EqualFold("And", t.Name.Local): 8669 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8670 if err := awsRestxml_deserializeDocumentLifecycleRuleAndOperator(&sv.And, nodeDecoder); err != nil { 8671 return err 8672 } 8673 8674 case strings.EqualFold("Prefix", t.Name.Local): 8675 val, err := decoder.Value() 8676 if err != nil { 8677 return err 8678 } 8679 if val == nil { 8680 break 8681 } 8682 { 8683 xtv := string(val) 8684 sv.Prefix = ptr.String(xtv) 8685 } 8686 8687 case strings.EqualFold("Tag", t.Name.Local): 8688 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8689 if err := awsRestxml_deserializeDocumentS3Tag(&sv.Tag, nodeDecoder); err != nil { 8690 return err 8691 } 8692 8693 default: 8694 // Do nothing and ignore the unexpected tag element 8695 err = decoder.Decoder.Skip() 8696 if err != nil { 8697 return err 8698 } 8699 8700 } 8701 decoder = originalDecoder 8702 } 8703 *v = sv 8704 return nil 8705} 8706 8707func awsRestxml_deserializeDocumentLifecycleRules(v *[]types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 8708 if v == nil { 8709 return fmt.Errorf("unexpected nil of type %T", v) 8710 } 8711 var sv []types.LifecycleRule 8712 if *v == nil { 8713 sv = make([]types.LifecycleRule, 0) 8714 } else { 8715 sv = *v 8716 } 8717 8718 originalDecoder := decoder 8719 for { 8720 t, done, err := decoder.Token() 8721 if err != nil { 8722 return err 8723 } 8724 if done { 8725 break 8726 } 8727 switch { 8728 case strings.EqualFold("Rule", t.Name.Local): 8729 var col types.LifecycleRule 8730 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8731 destAddr := &col 8732 if err := awsRestxml_deserializeDocumentLifecycleRule(&destAddr, nodeDecoder); err != nil { 8733 return err 8734 } 8735 col = *destAddr 8736 sv = append(sv, col) 8737 8738 default: 8739 err = decoder.Decoder.Skip() 8740 if err != nil { 8741 return err 8742 } 8743 8744 } 8745 decoder = originalDecoder 8746 } 8747 *v = sv 8748 return nil 8749} 8750 8751func awsRestxml_deserializeDocumentLifecycleRulesUnwrapped(v *[]types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 8752 var sv []types.LifecycleRule 8753 if *v == nil { 8754 sv = make([]types.LifecycleRule, 0) 8755 } else { 8756 sv = *v 8757 } 8758 8759 switch { 8760 default: 8761 var mv types.LifecycleRule 8762 t := decoder.StartEl 8763 _ = t 8764 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8765 destAddr := &mv 8766 if err := awsRestxml_deserializeDocumentLifecycleRule(&destAddr, nodeDecoder); err != nil { 8767 return err 8768 } 8769 mv = *destAddr 8770 sv = append(sv, mv) 8771 } 8772 *v = sv 8773 return nil 8774} 8775func awsRestxml_deserializeDocumentListStorageLensConfigurationEntry(v **types.ListStorageLensConfigurationEntry, decoder smithyxml.NodeDecoder) error { 8776 if v == nil { 8777 return fmt.Errorf("unexpected nil of type %T", v) 8778 } 8779 var sv *types.ListStorageLensConfigurationEntry 8780 if *v == nil { 8781 sv = &types.ListStorageLensConfigurationEntry{} 8782 } else { 8783 sv = *v 8784 } 8785 8786 for { 8787 t, done, err := decoder.Token() 8788 if err != nil { 8789 return err 8790 } 8791 if done { 8792 break 8793 } 8794 originalDecoder := decoder 8795 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8796 switch { 8797 case strings.EqualFold("HomeRegion", t.Name.Local): 8798 val, err := decoder.Value() 8799 if err != nil { 8800 return err 8801 } 8802 if val == nil { 8803 break 8804 } 8805 { 8806 xtv := string(val) 8807 sv.HomeRegion = ptr.String(xtv) 8808 } 8809 8810 case strings.EqualFold("Id", t.Name.Local): 8811 val, err := decoder.Value() 8812 if err != nil { 8813 return err 8814 } 8815 if val == nil { 8816 break 8817 } 8818 { 8819 xtv := string(val) 8820 sv.Id = ptr.String(xtv) 8821 } 8822 8823 case strings.EqualFold("IsEnabled", t.Name.Local): 8824 val, err := decoder.Value() 8825 if err != nil { 8826 return err 8827 } 8828 if val == nil { 8829 break 8830 } 8831 { 8832 xtv, err := strconv.ParseBool(string(val)) 8833 if err != nil { 8834 return fmt.Errorf("expected IsEnabled to be of type *bool, got %T instead", val) 8835 } 8836 sv.IsEnabled = xtv 8837 } 8838 8839 case strings.EqualFold("StorageLensArn", t.Name.Local): 8840 val, err := decoder.Value() 8841 if err != nil { 8842 return err 8843 } 8844 if val == nil { 8845 break 8846 } 8847 { 8848 xtv := string(val) 8849 sv.StorageLensArn = ptr.String(xtv) 8850 } 8851 8852 default: 8853 // Do nothing and ignore the unexpected tag element 8854 err = decoder.Decoder.Skip() 8855 if err != nil { 8856 return err 8857 } 8858 8859 } 8860 decoder = originalDecoder 8861 } 8862 *v = sv 8863 return nil 8864} 8865 8866func awsRestxml_deserializeDocumentNoncurrentVersionExpiration(v **types.NoncurrentVersionExpiration, decoder smithyxml.NodeDecoder) error { 8867 if v == nil { 8868 return fmt.Errorf("unexpected nil of type %T", v) 8869 } 8870 var sv *types.NoncurrentVersionExpiration 8871 if *v == nil { 8872 sv = &types.NoncurrentVersionExpiration{} 8873 } else { 8874 sv = *v 8875 } 8876 8877 for { 8878 t, done, err := decoder.Token() 8879 if err != nil { 8880 return err 8881 } 8882 if done { 8883 break 8884 } 8885 originalDecoder := decoder 8886 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8887 switch { 8888 case strings.EqualFold("NoncurrentDays", t.Name.Local): 8889 val, err := decoder.Value() 8890 if err != nil { 8891 return err 8892 } 8893 if val == nil { 8894 break 8895 } 8896 { 8897 xtv := string(val) 8898 i64, err := strconv.ParseInt(xtv, 10, 64) 8899 if err != nil { 8900 return err 8901 } 8902 sv.NoncurrentDays = int32(i64) 8903 } 8904 8905 default: 8906 // Do nothing and ignore the unexpected tag element 8907 err = decoder.Decoder.Skip() 8908 if err != nil { 8909 return err 8910 } 8911 8912 } 8913 decoder = originalDecoder 8914 } 8915 *v = sv 8916 return nil 8917} 8918 8919func awsRestxml_deserializeDocumentNoncurrentVersionTransition(v **types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 8920 if v == nil { 8921 return fmt.Errorf("unexpected nil of type %T", v) 8922 } 8923 var sv *types.NoncurrentVersionTransition 8924 if *v == nil { 8925 sv = &types.NoncurrentVersionTransition{} 8926 } else { 8927 sv = *v 8928 } 8929 8930 for { 8931 t, done, err := decoder.Token() 8932 if err != nil { 8933 return err 8934 } 8935 if done { 8936 break 8937 } 8938 originalDecoder := decoder 8939 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8940 switch { 8941 case strings.EqualFold("NoncurrentDays", t.Name.Local): 8942 val, err := decoder.Value() 8943 if err != nil { 8944 return err 8945 } 8946 if val == nil { 8947 break 8948 } 8949 { 8950 xtv := string(val) 8951 i64, err := strconv.ParseInt(xtv, 10, 64) 8952 if err != nil { 8953 return err 8954 } 8955 sv.NoncurrentDays = int32(i64) 8956 } 8957 8958 case strings.EqualFold("StorageClass", t.Name.Local): 8959 val, err := decoder.Value() 8960 if err != nil { 8961 return err 8962 } 8963 if val == nil { 8964 break 8965 } 8966 { 8967 xtv := string(val) 8968 sv.StorageClass = types.TransitionStorageClass(xtv) 8969 } 8970 8971 default: 8972 // Do nothing and ignore the unexpected tag element 8973 err = decoder.Decoder.Skip() 8974 if err != nil { 8975 return err 8976 } 8977 8978 } 8979 decoder = originalDecoder 8980 } 8981 *v = sv 8982 return nil 8983} 8984 8985func awsRestxml_deserializeDocumentNoncurrentVersionTransitionList(v *[]types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 8986 if v == nil { 8987 return fmt.Errorf("unexpected nil of type %T", v) 8988 } 8989 var sv []types.NoncurrentVersionTransition 8990 if *v == nil { 8991 sv = make([]types.NoncurrentVersionTransition, 0) 8992 } else { 8993 sv = *v 8994 } 8995 8996 originalDecoder := decoder 8997 for { 8998 t, done, err := decoder.Token() 8999 if err != nil { 9000 return err 9001 } 9002 if done { 9003 break 9004 } 9005 switch { 9006 case strings.EqualFold("NoncurrentVersionTransition", t.Name.Local): 9007 var col types.NoncurrentVersionTransition 9008 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9009 destAddr := &col 9010 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransition(&destAddr, nodeDecoder); err != nil { 9011 return err 9012 } 9013 col = *destAddr 9014 sv = append(sv, col) 9015 9016 default: 9017 err = decoder.Decoder.Skip() 9018 if err != nil { 9019 return err 9020 } 9021 9022 } 9023 decoder = originalDecoder 9024 } 9025 *v = sv 9026 return nil 9027} 9028 9029func awsRestxml_deserializeDocumentNoncurrentVersionTransitionListUnwrapped(v *[]types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 9030 var sv []types.NoncurrentVersionTransition 9031 if *v == nil { 9032 sv = make([]types.NoncurrentVersionTransition, 0) 9033 } else { 9034 sv = *v 9035 } 9036 9037 switch { 9038 default: 9039 var mv types.NoncurrentVersionTransition 9040 t := decoder.StartEl 9041 _ = t 9042 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9043 destAddr := &mv 9044 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransition(&destAddr, nodeDecoder); err != nil { 9045 return err 9046 } 9047 mv = *destAddr 9048 sv = append(sv, mv) 9049 } 9050 *v = sv 9051 return nil 9052} 9053func awsRestxml_deserializeDocumentNoSuchPublicAccessBlockConfiguration(v **types.NoSuchPublicAccessBlockConfiguration, decoder smithyxml.NodeDecoder) error { 9054 if v == nil { 9055 return fmt.Errorf("unexpected nil of type %T", v) 9056 } 9057 var sv *types.NoSuchPublicAccessBlockConfiguration 9058 if *v == nil { 9059 sv = &types.NoSuchPublicAccessBlockConfiguration{} 9060 } else { 9061 sv = *v 9062 } 9063 9064 for { 9065 t, done, err := decoder.Token() 9066 if err != nil { 9067 return err 9068 } 9069 if done { 9070 break 9071 } 9072 originalDecoder := decoder 9073 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9074 switch { 9075 case strings.EqualFold("Message", t.Name.Local): 9076 val, err := decoder.Value() 9077 if err != nil { 9078 return err 9079 } 9080 if val == nil { 9081 break 9082 } 9083 { 9084 xtv := string(val) 9085 sv.Message = ptr.String(xtv) 9086 } 9087 9088 default: 9089 // Do nothing and ignore the unexpected tag element 9090 err = decoder.Decoder.Skip() 9091 if err != nil { 9092 return err 9093 } 9094 9095 } 9096 decoder = originalDecoder 9097 } 9098 *v = sv 9099 return nil 9100} 9101 9102func awsRestxml_deserializeDocumentNotFoundException(v **types.NotFoundException, decoder smithyxml.NodeDecoder) error { 9103 if v == nil { 9104 return fmt.Errorf("unexpected nil of type %T", v) 9105 } 9106 var sv *types.NotFoundException 9107 if *v == nil { 9108 sv = &types.NotFoundException{} 9109 } else { 9110 sv = *v 9111 } 9112 9113 for { 9114 t, done, err := decoder.Token() 9115 if err != nil { 9116 return err 9117 } 9118 if done { 9119 break 9120 } 9121 originalDecoder := decoder 9122 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9123 switch { 9124 case strings.EqualFold("Message", t.Name.Local): 9125 val, err := decoder.Value() 9126 if err != nil { 9127 return err 9128 } 9129 if val == nil { 9130 break 9131 } 9132 { 9133 xtv := string(val) 9134 sv.Message = ptr.String(xtv) 9135 } 9136 9137 default: 9138 // Do nothing and ignore the unexpected tag element 9139 err = decoder.Decoder.Skip() 9140 if err != nil { 9141 return err 9142 } 9143 9144 } 9145 decoder = originalDecoder 9146 } 9147 *v = sv 9148 return nil 9149} 9150 9151func awsRestxml_deserializeDocumentObjectLambdaAccessPoint(v **types.ObjectLambdaAccessPoint, decoder smithyxml.NodeDecoder) error { 9152 if v == nil { 9153 return fmt.Errorf("unexpected nil of type %T", v) 9154 } 9155 var sv *types.ObjectLambdaAccessPoint 9156 if *v == nil { 9157 sv = &types.ObjectLambdaAccessPoint{} 9158 } else { 9159 sv = *v 9160 } 9161 9162 for { 9163 t, done, err := decoder.Token() 9164 if err != nil { 9165 return err 9166 } 9167 if done { 9168 break 9169 } 9170 originalDecoder := decoder 9171 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9172 switch { 9173 case strings.EqualFold("Name", t.Name.Local): 9174 val, err := decoder.Value() 9175 if err != nil { 9176 return err 9177 } 9178 if val == nil { 9179 break 9180 } 9181 { 9182 xtv := string(val) 9183 sv.Name = ptr.String(xtv) 9184 } 9185 9186 case strings.EqualFold("ObjectLambdaAccessPointArn", t.Name.Local): 9187 val, err := decoder.Value() 9188 if err != nil { 9189 return err 9190 } 9191 if val == nil { 9192 break 9193 } 9194 { 9195 xtv := string(val) 9196 sv.ObjectLambdaAccessPointArn = ptr.String(xtv) 9197 } 9198 9199 default: 9200 // Do nothing and ignore the unexpected tag element 9201 err = decoder.Decoder.Skip() 9202 if err != nil { 9203 return err 9204 } 9205 9206 } 9207 decoder = originalDecoder 9208 } 9209 *v = sv 9210 return nil 9211} 9212 9213func awsRestxml_deserializeDocumentObjectLambdaAccessPointList(v *[]types.ObjectLambdaAccessPoint, decoder smithyxml.NodeDecoder) error { 9214 if v == nil { 9215 return fmt.Errorf("unexpected nil of type %T", v) 9216 } 9217 var sv []types.ObjectLambdaAccessPoint 9218 if *v == nil { 9219 sv = make([]types.ObjectLambdaAccessPoint, 0) 9220 } else { 9221 sv = *v 9222 } 9223 9224 originalDecoder := decoder 9225 for { 9226 t, done, err := decoder.Token() 9227 if err != nil { 9228 return err 9229 } 9230 if done { 9231 break 9232 } 9233 switch { 9234 case strings.EqualFold("ObjectLambdaAccessPoint", t.Name.Local): 9235 var col types.ObjectLambdaAccessPoint 9236 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9237 destAddr := &col 9238 if err := awsRestxml_deserializeDocumentObjectLambdaAccessPoint(&destAddr, nodeDecoder); err != nil { 9239 return err 9240 } 9241 col = *destAddr 9242 sv = append(sv, col) 9243 9244 default: 9245 err = decoder.Decoder.Skip() 9246 if err != nil { 9247 return err 9248 } 9249 9250 } 9251 decoder = originalDecoder 9252 } 9253 *v = sv 9254 return nil 9255} 9256 9257func awsRestxml_deserializeDocumentObjectLambdaAccessPointListUnwrapped(v *[]types.ObjectLambdaAccessPoint, decoder smithyxml.NodeDecoder) error { 9258 var sv []types.ObjectLambdaAccessPoint 9259 if *v == nil { 9260 sv = make([]types.ObjectLambdaAccessPoint, 0) 9261 } else { 9262 sv = *v 9263 } 9264 9265 switch { 9266 default: 9267 var mv types.ObjectLambdaAccessPoint 9268 t := decoder.StartEl 9269 _ = t 9270 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9271 destAddr := &mv 9272 if err := awsRestxml_deserializeDocumentObjectLambdaAccessPoint(&destAddr, nodeDecoder); err != nil { 9273 return err 9274 } 9275 mv = *destAddr 9276 sv = append(sv, mv) 9277 } 9278 *v = sv 9279 return nil 9280} 9281func awsRestxml_deserializeDocumentObjectLambdaAllowedFeaturesList(v *[]types.ObjectLambdaAllowedFeature, decoder smithyxml.NodeDecoder) error { 9282 if v == nil { 9283 return fmt.Errorf("unexpected nil of type %T", v) 9284 } 9285 var sv []types.ObjectLambdaAllowedFeature 9286 if *v == nil { 9287 sv = make([]types.ObjectLambdaAllowedFeature, 0) 9288 } else { 9289 sv = *v 9290 } 9291 9292 originalDecoder := decoder 9293 for { 9294 t, done, err := decoder.Token() 9295 if err != nil { 9296 return err 9297 } 9298 if done { 9299 break 9300 } 9301 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9302 decoder = memberDecoder 9303 switch { 9304 case strings.EqualFold("AllowedFeature", t.Name.Local): 9305 var col types.ObjectLambdaAllowedFeature 9306 val, err := decoder.Value() 9307 if err != nil { 9308 return err 9309 } 9310 if val == nil { 9311 break 9312 } 9313 { 9314 xtv := string(val) 9315 col = types.ObjectLambdaAllowedFeature(xtv) 9316 } 9317 sv = append(sv, col) 9318 9319 default: 9320 err = decoder.Decoder.Skip() 9321 if err != nil { 9322 return err 9323 } 9324 9325 } 9326 decoder = originalDecoder 9327 } 9328 *v = sv 9329 return nil 9330} 9331 9332func awsRestxml_deserializeDocumentObjectLambdaAllowedFeaturesListUnwrapped(v *[]types.ObjectLambdaAllowedFeature, decoder smithyxml.NodeDecoder) error { 9333 var sv []types.ObjectLambdaAllowedFeature 9334 if *v == nil { 9335 sv = make([]types.ObjectLambdaAllowedFeature, 0) 9336 } else { 9337 sv = *v 9338 } 9339 9340 switch { 9341 default: 9342 var mv types.ObjectLambdaAllowedFeature 9343 t := decoder.StartEl 9344 _ = t 9345 val, err := decoder.Value() 9346 if err != nil { 9347 return err 9348 } 9349 if val == nil { 9350 break 9351 } 9352 { 9353 xtv := string(val) 9354 mv = types.ObjectLambdaAllowedFeature(xtv) 9355 } 9356 sv = append(sv, mv) 9357 } 9358 *v = sv 9359 return nil 9360} 9361func awsRestxml_deserializeDocumentObjectLambdaConfiguration(v **types.ObjectLambdaConfiguration, decoder smithyxml.NodeDecoder) error { 9362 if v == nil { 9363 return fmt.Errorf("unexpected nil of type %T", v) 9364 } 9365 var sv *types.ObjectLambdaConfiguration 9366 if *v == nil { 9367 sv = &types.ObjectLambdaConfiguration{} 9368 } else { 9369 sv = *v 9370 } 9371 9372 for { 9373 t, done, err := decoder.Token() 9374 if err != nil { 9375 return err 9376 } 9377 if done { 9378 break 9379 } 9380 originalDecoder := decoder 9381 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9382 switch { 9383 case strings.EqualFold("AllowedFeatures", t.Name.Local): 9384 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9385 if err := awsRestxml_deserializeDocumentObjectLambdaAllowedFeaturesList(&sv.AllowedFeatures, nodeDecoder); err != nil { 9386 return err 9387 } 9388 9389 case strings.EqualFold("CloudWatchMetricsEnabled", t.Name.Local): 9390 val, err := decoder.Value() 9391 if err != nil { 9392 return err 9393 } 9394 if val == nil { 9395 break 9396 } 9397 { 9398 xtv, err := strconv.ParseBool(string(val)) 9399 if err != nil { 9400 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 9401 } 9402 sv.CloudWatchMetricsEnabled = xtv 9403 } 9404 9405 case strings.EqualFold("SupportingAccessPoint", t.Name.Local): 9406 val, err := decoder.Value() 9407 if err != nil { 9408 return err 9409 } 9410 if val == nil { 9411 break 9412 } 9413 { 9414 xtv := string(val) 9415 sv.SupportingAccessPoint = ptr.String(xtv) 9416 } 9417 9418 case strings.EqualFold("TransformationConfigurations", t.Name.Local): 9419 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9420 if err := awsRestxml_deserializeDocumentObjectLambdaTransformationConfigurationsList(&sv.TransformationConfigurations, nodeDecoder); err != nil { 9421 return err 9422 } 9423 9424 default: 9425 // Do nothing and ignore the unexpected tag element 9426 err = decoder.Decoder.Skip() 9427 if err != nil { 9428 return err 9429 } 9430 9431 } 9432 decoder = originalDecoder 9433 } 9434 *v = sv 9435 return nil 9436} 9437 9438func awsRestxml_deserializeDocumentObjectLambdaContentTransformation(v *types.ObjectLambdaContentTransformation, decoder smithyxml.NodeDecoder) error { 9439 if v == nil { 9440 return fmt.Errorf("unexpected nil of type %T", v) 9441 } 9442 var uv types.ObjectLambdaContentTransformation 9443 var memberFound bool 9444 for { 9445 t, done, err := decoder.Token() 9446 if err != nil { 9447 return err 9448 } 9449 if done { 9450 break 9451 } 9452 if memberFound { 9453 if err = decoder.Decoder.Skip(); err != nil { 9454 return err 9455 } 9456 } 9457 originalDecoder := decoder 9458 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9459 switch { 9460 case strings.EqualFold("AwsLambda", t.Name.Local): 9461 var mv types.AwsLambdaTransformation 9462 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9463 destAddr := &mv 9464 if err := awsRestxml_deserializeDocumentAwsLambdaTransformation(&destAddr, nodeDecoder); err != nil { 9465 return err 9466 } 9467 mv = *destAddr 9468 uv = &types.ObjectLambdaContentTransformationMemberAwsLambda{Value: mv} 9469 memberFound = true 9470 9471 default: 9472 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 9473 memberFound = true 9474 9475 } 9476 decoder = originalDecoder 9477 } 9478 *v = uv 9479 return nil 9480} 9481 9482func awsRestxml_deserializeDocumentObjectLambdaTransformationConfiguration(v **types.ObjectLambdaTransformationConfiguration, decoder smithyxml.NodeDecoder) error { 9483 if v == nil { 9484 return fmt.Errorf("unexpected nil of type %T", v) 9485 } 9486 var sv *types.ObjectLambdaTransformationConfiguration 9487 if *v == nil { 9488 sv = &types.ObjectLambdaTransformationConfiguration{} 9489 } else { 9490 sv = *v 9491 } 9492 9493 for { 9494 t, done, err := decoder.Token() 9495 if err != nil { 9496 return err 9497 } 9498 if done { 9499 break 9500 } 9501 originalDecoder := decoder 9502 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9503 switch { 9504 case strings.EqualFold("Actions", t.Name.Local): 9505 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9506 if err := awsRestxml_deserializeDocumentObjectLambdaTransformationConfigurationActionsList(&sv.Actions, nodeDecoder); err != nil { 9507 return err 9508 } 9509 9510 case strings.EqualFold("ContentTransformation", t.Name.Local): 9511 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9512 if err := awsRestxml_deserializeDocumentObjectLambdaContentTransformation(&sv.ContentTransformation, nodeDecoder); err != nil { 9513 return err 9514 } 9515 9516 default: 9517 // Do nothing and ignore the unexpected tag element 9518 err = decoder.Decoder.Skip() 9519 if err != nil { 9520 return err 9521 } 9522 9523 } 9524 decoder = originalDecoder 9525 } 9526 *v = sv 9527 return nil 9528} 9529 9530func awsRestxml_deserializeDocumentObjectLambdaTransformationConfigurationActionsList(v *[]types.ObjectLambdaTransformationConfigurationAction, decoder smithyxml.NodeDecoder) error { 9531 if v == nil { 9532 return fmt.Errorf("unexpected nil of type %T", v) 9533 } 9534 var sv []types.ObjectLambdaTransformationConfigurationAction 9535 if *v == nil { 9536 sv = make([]types.ObjectLambdaTransformationConfigurationAction, 0) 9537 } else { 9538 sv = *v 9539 } 9540 9541 originalDecoder := decoder 9542 for { 9543 t, done, err := decoder.Token() 9544 if err != nil { 9545 return err 9546 } 9547 if done { 9548 break 9549 } 9550 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9551 decoder = memberDecoder 9552 switch { 9553 case strings.EqualFold("Action", t.Name.Local): 9554 var col types.ObjectLambdaTransformationConfigurationAction 9555 val, err := decoder.Value() 9556 if err != nil { 9557 return err 9558 } 9559 if val == nil { 9560 break 9561 } 9562 { 9563 xtv := string(val) 9564 col = types.ObjectLambdaTransformationConfigurationAction(xtv) 9565 } 9566 sv = append(sv, col) 9567 9568 default: 9569 err = decoder.Decoder.Skip() 9570 if err != nil { 9571 return err 9572 } 9573 9574 } 9575 decoder = originalDecoder 9576 } 9577 *v = sv 9578 return nil 9579} 9580 9581func awsRestxml_deserializeDocumentObjectLambdaTransformationConfigurationActionsListUnwrapped(v *[]types.ObjectLambdaTransformationConfigurationAction, decoder smithyxml.NodeDecoder) error { 9582 var sv []types.ObjectLambdaTransformationConfigurationAction 9583 if *v == nil { 9584 sv = make([]types.ObjectLambdaTransformationConfigurationAction, 0) 9585 } else { 9586 sv = *v 9587 } 9588 9589 switch { 9590 default: 9591 var mv types.ObjectLambdaTransformationConfigurationAction 9592 t := decoder.StartEl 9593 _ = t 9594 val, err := decoder.Value() 9595 if err != nil { 9596 return err 9597 } 9598 if val == nil { 9599 break 9600 } 9601 { 9602 xtv := string(val) 9603 mv = types.ObjectLambdaTransformationConfigurationAction(xtv) 9604 } 9605 sv = append(sv, mv) 9606 } 9607 *v = sv 9608 return nil 9609} 9610func awsRestxml_deserializeDocumentObjectLambdaTransformationConfigurationsList(v *[]types.ObjectLambdaTransformationConfiguration, decoder smithyxml.NodeDecoder) error { 9611 if v == nil { 9612 return fmt.Errorf("unexpected nil of type %T", v) 9613 } 9614 var sv []types.ObjectLambdaTransformationConfiguration 9615 if *v == nil { 9616 sv = make([]types.ObjectLambdaTransformationConfiguration, 0) 9617 } else { 9618 sv = *v 9619 } 9620 9621 originalDecoder := decoder 9622 for { 9623 t, done, err := decoder.Token() 9624 if err != nil { 9625 return err 9626 } 9627 if done { 9628 break 9629 } 9630 switch { 9631 case strings.EqualFold("TransformationConfiguration", t.Name.Local): 9632 var col types.ObjectLambdaTransformationConfiguration 9633 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9634 destAddr := &col 9635 if err := awsRestxml_deserializeDocumentObjectLambdaTransformationConfiguration(&destAddr, nodeDecoder); err != nil { 9636 return err 9637 } 9638 col = *destAddr 9639 sv = append(sv, col) 9640 9641 default: 9642 err = decoder.Decoder.Skip() 9643 if err != nil { 9644 return err 9645 } 9646 9647 } 9648 decoder = originalDecoder 9649 } 9650 *v = sv 9651 return nil 9652} 9653 9654func awsRestxml_deserializeDocumentObjectLambdaTransformationConfigurationsListUnwrapped(v *[]types.ObjectLambdaTransformationConfiguration, decoder smithyxml.NodeDecoder) error { 9655 var sv []types.ObjectLambdaTransformationConfiguration 9656 if *v == nil { 9657 sv = make([]types.ObjectLambdaTransformationConfiguration, 0) 9658 } else { 9659 sv = *v 9660 } 9661 9662 switch { 9663 default: 9664 var mv types.ObjectLambdaTransformationConfiguration 9665 t := decoder.StartEl 9666 _ = t 9667 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9668 destAddr := &mv 9669 if err := awsRestxml_deserializeDocumentObjectLambdaTransformationConfiguration(&destAddr, nodeDecoder); err != nil { 9670 return err 9671 } 9672 mv = *destAddr 9673 sv = append(sv, mv) 9674 } 9675 *v = sv 9676 return nil 9677} 9678func awsRestxml_deserializeDocumentPolicyStatus(v **types.PolicyStatus, decoder smithyxml.NodeDecoder) error { 9679 if v == nil { 9680 return fmt.Errorf("unexpected nil of type %T", v) 9681 } 9682 var sv *types.PolicyStatus 9683 if *v == nil { 9684 sv = &types.PolicyStatus{} 9685 } else { 9686 sv = *v 9687 } 9688 9689 for { 9690 t, done, err := decoder.Token() 9691 if err != nil { 9692 return err 9693 } 9694 if done { 9695 break 9696 } 9697 originalDecoder := decoder 9698 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9699 switch { 9700 case strings.EqualFold("IsPublic", t.Name.Local): 9701 val, err := decoder.Value() 9702 if err != nil { 9703 return err 9704 } 9705 if val == nil { 9706 break 9707 } 9708 { 9709 xtv, err := strconv.ParseBool(string(val)) 9710 if err != nil { 9711 return fmt.Errorf("expected IsPublic to be of type *bool, got %T instead", val) 9712 } 9713 sv.IsPublic = xtv 9714 } 9715 9716 default: 9717 // Do nothing and ignore the unexpected tag element 9718 err = decoder.Decoder.Skip() 9719 if err != nil { 9720 return err 9721 } 9722 9723 } 9724 decoder = originalDecoder 9725 } 9726 *v = sv 9727 return nil 9728} 9729 9730func awsRestxml_deserializeDocumentPrefixLevel(v **types.PrefixLevel, decoder smithyxml.NodeDecoder) error { 9731 if v == nil { 9732 return fmt.Errorf("unexpected nil of type %T", v) 9733 } 9734 var sv *types.PrefixLevel 9735 if *v == nil { 9736 sv = &types.PrefixLevel{} 9737 } else { 9738 sv = *v 9739 } 9740 9741 for { 9742 t, done, err := decoder.Token() 9743 if err != nil { 9744 return err 9745 } 9746 if done { 9747 break 9748 } 9749 originalDecoder := decoder 9750 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9751 switch { 9752 case strings.EqualFold("StorageMetrics", t.Name.Local): 9753 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9754 if err := awsRestxml_deserializeDocumentPrefixLevelStorageMetrics(&sv.StorageMetrics, nodeDecoder); err != nil { 9755 return err 9756 } 9757 9758 default: 9759 // Do nothing and ignore the unexpected tag element 9760 err = decoder.Decoder.Skip() 9761 if err != nil { 9762 return err 9763 } 9764 9765 } 9766 decoder = originalDecoder 9767 } 9768 *v = sv 9769 return nil 9770} 9771 9772func awsRestxml_deserializeDocumentPrefixLevelStorageMetrics(v **types.PrefixLevelStorageMetrics, decoder smithyxml.NodeDecoder) error { 9773 if v == nil { 9774 return fmt.Errorf("unexpected nil of type %T", v) 9775 } 9776 var sv *types.PrefixLevelStorageMetrics 9777 if *v == nil { 9778 sv = &types.PrefixLevelStorageMetrics{} 9779 } else { 9780 sv = *v 9781 } 9782 9783 for { 9784 t, done, err := decoder.Token() 9785 if err != nil { 9786 return err 9787 } 9788 if done { 9789 break 9790 } 9791 originalDecoder := decoder 9792 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9793 switch { 9794 case strings.EqualFold("IsEnabled", t.Name.Local): 9795 val, err := decoder.Value() 9796 if err != nil { 9797 return err 9798 } 9799 if val == nil { 9800 break 9801 } 9802 { 9803 xtv, err := strconv.ParseBool(string(val)) 9804 if err != nil { 9805 return fmt.Errorf("expected IsEnabled to be of type *bool, got %T instead", val) 9806 } 9807 sv.IsEnabled = xtv 9808 } 9809 9810 case strings.EqualFold("SelectionCriteria", t.Name.Local): 9811 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9812 if err := awsRestxml_deserializeDocumentSelectionCriteria(&sv.SelectionCriteria, nodeDecoder); err != nil { 9813 return err 9814 } 9815 9816 default: 9817 // Do nothing and ignore the unexpected tag element 9818 err = decoder.Decoder.Skip() 9819 if err != nil { 9820 return err 9821 } 9822 9823 } 9824 decoder = originalDecoder 9825 } 9826 *v = sv 9827 return nil 9828} 9829 9830func awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(v **types.PublicAccessBlockConfiguration, decoder smithyxml.NodeDecoder) error { 9831 if v == nil { 9832 return fmt.Errorf("unexpected nil of type %T", v) 9833 } 9834 var sv *types.PublicAccessBlockConfiguration 9835 if *v == nil { 9836 sv = &types.PublicAccessBlockConfiguration{} 9837 } else { 9838 sv = *v 9839 } 9840 9841 for { 9842 t, done, err := decoder.Token() 9843 if err != nil { 9844 return err 9845 } 9846 if done { 9847 break 9848 } 9849 originalDecoder := decoder 9850 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9851 switch { 9852 case strings.EqualFold("BlockPublicAcls", t.Name.Local): 9853 val, err := decoder.Value() 9854 if err != nil { 9855 return err 9856 } 9857 if val == nil { 9858 break 9859 } 9860 { 9861 xtv, err := strconv.ParseBool(string(val)) 9862 if err != nil { 9863 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 9864 } 9865 sv.BlockPublicAcls = xtv 9866 } 9867 9868 case strings.EqualFold("BlockPublicPolicy", t.Name.Local): 9869 val, err := decoder.Value() 9870 if err != nil { 9871 return err 9872 } 9873 if val == nil { 9874 break 9875 } 9876 { 9877 xtv, err := strconv.ParseBool(string(val)) 9878 if err != nil { 9879 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 9880 } 9881 sv.BlockPublicPolicy = xtv 9882 } 9883 9884 case strings.EqualFold("IgnorePublicAcls", t.Name.Local): 9885 val, err := decoder.Value() 9886 if err != nil { 9887 return err 9888 } 9889 if val == nil { 9890 break 9891 } 9892 { 9893 xtv, err := strconv.ParseBool(string(val)) 9894 if err != nil { 9895 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 9896 } 9897 sv.IgnorePublicAcls = xtv 9898 } 9899 9900 case strings.EqualFold("RestrictPublicBuckets", t.Name.Local): 9901 val, err := decoder.Value() 9902 if err != nil { 9903 return err 9904 } 9905 if val == nil { 9906 break 9907 } 9908 { 9909 xtv, err := strconv.ParseBool(string(val)) 9910 if err != nil { 9911 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 9912 } 9913 sv.RestrictPublicBuckets = xtv 9914 } 9915 9916 default: 9917 // Do nothing and ignore the unexpected tag element 9918 err = decoder.Decoder.Skip() 9919 if err != nil { 9920 return err 9921 } 9922 9923 } 9924 decoder = originalDecoder 9925 } 9926 *v = sv 9927 return nil 9928} 9929 9930func awsRestxml_deserializeDocumentRegionalBucket(v **types.RegionalBucket, decoder smithyxml.NodeDecoder) error { 9931 if v == nil { 9932 return fmt.Errorf("unexpected nil of type %T", v) 9933 } 9934 var sv *types.RegionalBucket 9935 if *v == nil { 9936 sv = &types.RegionalBucket{} 9937 } else { 9938 sv = *v 9939 } 9940 9941 for { 9942 t, done, err := decoder.Token() 9943 if err != nil { 9944 return err 9945 } 9946 if done { 9947 break 9948 } 9949 originalDecoder := decoder 9950 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9951 switch { 9952 case strings.EqualFold("Bucket", t.Name.Local): 9953 val, err := decoder.Value() 9954 if err != nil { 9955 return err 9956 } 9957 if val == nil { 9958 break 9959 } 9960 { 9961 xtv := string(val) 9962 sv.Bucket = ptr.String(xtv) 9963 } 9964 9965 case strings.EqualFold("BucketArn", t.Name.Local): 9966 val, err := decoder.Value() 9967 if err != nil { 9968 return err 9969 } 9970 if val == nil { 9971 break 9972 } 9973 { 9974 xtv := string(val) 9975 sv.BucketArn = ptr.String(xtv) 9976 } 9977 9978 case strings.EqualFold("CreationDate", t.Name.Local): 9979 val, err := decoder.Value() 9980 if err != nil { 9981 return err 9982 } 9983 if val == nil { 9984 break 9985 } 9986 { 9987 xtv := string(val) 9988 t, err := smithytime.ParseDateTime(xtv) 9989 if err != nil { 9990 return err 9991 } 9992 sv.CreationDate = ptr.Time(t) 9993 } 9994 9995 case strings.EqualFold("OutpostId", t.Name.Local): 9996 val, err := decoder.Value() 9997 if err != nil { 9998 return err 9999 } 10000 if val == nil { 10001 break 10002 } 10003 { 10004 xtv := string(val) 10005 sv.OutpostId = ptr.String(xtv) 10006 } 10007 10008 case strings.EqualFold("PublicAccessBlockEnabled", t.Name.Local): 10009 val, err := decoder.Value() 10010 if err != nil { 10011 return err 10012 } 10013 if val == nil { 10014 break 10015 } 10016 { 10017 xtv, err := strconv.ParseBool(string(val)) 10018 if err != nil { 10019 return fmt.Errorf("expected PublicAccessBlockEnabled to be of type *bool, got %T instead", val) 10020 } 10021 sv.PublicAccessBlockEnabled = xtv 10022 } 10023 10024 default: 10025 // Do nothing and ignore the unexpected tag element 10026 err = decoder.Decoder.Skip() 10027 if err != nil { 10028 return err 10029 } 10030 10031 } 10032 decoder = originalDecoder 10033 } 10034 *v = sv 10035 return nil 10036} 10037 10038func awsRestxml_deserializeDocumentRegionalBucketList(v *[]types.RegionalBucket, decoder smithyxml.NodeDecoder) error { 10039 if v == nil { 10040 return fmt.Errorf("unexpected nil of type %T", v) 10041 } 10042 var sv []types.RegionalBucket 10043 if *v == nil { 10044 sv = make([]types.RegionalBucket, 0) 10045 } else { 10046 sv = *v 10047 } 10048 10049 originalDecoder := decoder 10050 for { 10051 t, done, err := decoder.Token() 10052 if err != nil { 10053 return err 10054 } 10055 if done { 10056 break 10057 } 10058 switch { 10059 case strings.EqualFold("RegionalBucket", t.Name.Local): 10060 var col types.RegionalBucket 10061 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10062 destAddr := &col 10063 if err := awsRestxml_deserializeDocumentRegionalBucket(&destAddr, nodeDecoder); err != nil { 10064 return err 10065 } 10066 col = *destAddr 10067 sv = append(sv, col) 10068 10069 default: 10070 err = decoder.Decoder.Skip() 10071 if err != nil { 10072 return err 10073 } 10074 10075 } 10076 decoder = originalDecoder 10077 } 10078 *v = sv 10079 return nil 10080} 10081 10082func awsRestxml_deserializeDocumentRegionalBucketListUnwrapped(v *[]types.RegionalBucket, decoder smithyxml.NodeDecoder) error { 10083 var sv []types.RegionalBucket 10084 if *v == nil { 10085 sv = make([]types.RegionalBucket, 0) 10086 } else { 10087 sv = *v 10088 } 10089 10090 switch { 10091 default: 10092 var mv types.RegionalBucket 10093 t := decoder.StartEl 10094 _ = t 10095 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10096 destAddr := &mv 10097 if err := awsRestxml_deserializeDocumentRegionalBucket(&destAddr, nodeDecoder); err != nil { 10098 return err 10099 } 10100 mv = *destAddr 10101 sv = append(sv, mv) 10102 } 10103 *v = sv 10104 return nil 10105} 10106func awsRestxml_deserializeDocumentRegions(v *[]string, decoder smithyxml.NodeDecoder) error { 10107 if v == nil { 10108 return fmt.Errorf("unexpected nil of type %T", v) 10109 } 10110 var sv []string 10111 if *v == nil { 10112 sv = make([]string, 0) 10113 } else { 10114 sv = *v 10115 } 10116 10117 originalDecoder := decoder 10118 for { 10119 t, done, err := decoder.Token() 10120 if err != nil { 10121 return err 10122 } 10123 if done { 10124 break 10125 } 10126 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10127 decoder = memberDecoder 10128 switch { 10129 case strings.EqualFold("Region", t.Name.Local): 10130 var col string 10131 val, err := decoder.Value() 10132 if err != nil { 10133 return err 10134 } 10135 if val == nil { 10136 break 10137 } 10138 { 10139 xtv := string(val) 10140 col = xtv 10141 } 10142 sv = append(sv, col) 10143 10144 default: 10145 err = decoder.Decoder.Skip() 10146 if err != nil { 10147 return err 10148 } 10149 10150 } 10151 decoder = originalDecoder 10152 } 10153 *v = sv 10154 return nil 10155} 10156 10157func awsRestxml_deserializeDocumentRegionsUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 10158 var sv []string 10159 if *v == nil { 10160 sv = make([]string, 0) 10161 } else { 10162 sv = *v 10163 } 10164 10165 switch { 10166 default: 10167 var mv string 10168 t := decoder.StartEl 10169 _ = t 10170 val, err := decoder.Value() 10171 if err != nil { 10172 return err 10173 } 10174 if val == nil { 10175 break 10176 } 10177 { 10178 xtv := string(val) 10179 mv = xtv 10180 } 10181 sv = append(sv, mv) 10182 } 10183 *v = sv 10184 return nil 10185} 10186func awsRestxml_deserializeDocumentS3AccessControlList(v **types.S3AccessControlList, decoder smithyxml.NodeDecoder) error { 10187 if v == nil { 10188 return fmt.Errorf("unexpected nil of type %T", v) 10189 } 10190 var sv *types.S3AccessControlList 10191 if *v == nil { 10192 sv = &types.S3AccessControlList{} 10193 } else { 10194 sv = *v 10195 } 10196 10197 for { 10198 t, done, err := decoder.Token() 10199 if err != nil { 10200 return err 10201 } 10202 if done { 10203 break 10204 } 10205 originalDecoder := decoder 10206 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10207 switch { 10208 case strings.EqualFold("Grants", t.Name.Local): 10209 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10210 if err := awsRestxml_deserializeDocumentS3GrantList(&sv.Grants, nodeDecoder); err != nil { 10211 return err 10212 } 10213 10214 case strings.EqualFold("Owner", t.Name.Local): 10215 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10216 if err := awsRestxml_deserializeDocumentS3ObjectOwner(&sv.Owner, nodeDecoder); err != nil { 10217 return err 10218 } 10219 10220 default: 10221 // Do nothing and ignore the unexpected tag element 10222 err = decoder.Decoder.Skip() 10223 if err != nil { 10224 return err 10225 } 10226 10227 } 10228 decoder = originalDecoder 10229 } 10230 *v = sv 10231 return nil 10232} 10233 10234func awsRestxml_deserializeDocumentS3AccessControlPolicy(v **types.S3AccessControlPolicy, decoder smithyxml.NodeDecoder) error { 10235 if v == nil { 10236 return fmt.Errorf("unexpected nil of type %T", v) 10237 } 10238 var sv *types.S3AccessControlPolicy 10239 if *v == nil { 10240 sv = &types.S3AccessControlPolicy{} 10241 } else { 10242 sv = *v 10243 } 10244 10245 for { 10246 t, done, err := decoder.Token() 10247 if err != nil { 10248 return err 10249 } 10250 if done { 10251 break 10252 } 10253 originalDecoder := decoder 10254 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10255 switch { 10256 case strings.EqualFold("AccessControlList", t.Name.Local): 10257 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10258 if err := awsRestxml_deserializeDocumentS3AccessControlList(&sv.AccessControlList, nodeDecoder); err != nil { 10259 return err 10260 } 10261 10262 case strings.EqualFold("CannedAccessControlList", t.Name.Local): 10263 val, err := decoder.Value() 10264 if err != nil { 10265 return err 10266 } 10267 if val == nil { 10268 break 10269 } 10270 { 10271 xtv := string(val) 10272 sv.CannedAccessControlList = types.S3CannedAccessControlList(xtv) 10273 } 10274 10275 default: 10276 // Do nothing and ignore the unexpected tag element 10277 err = decoder.Decoder.Skip() 10278 if err != nil { 10279 return err 10280 } 10281 10282 } 10283 decoder = originalDecoder 10284 } 10285 *v = sv 10286 return nil 10287} 10288 10289func awsRestxml_deserializeDocumentS3BucketDestination(v **types.S3BucketDestination, decoder smithyxml.NodeDecoder) error { 10290 if v == nil { 10291 return fmt.Errorf("unexpected nil of type %T", v) 10292 } 10293 var sv *types.S3BucketDestination 10294 if *v == nil { 10295 sv = &types.S3BucketDestination{} 10296 } else { 10297 sv = *v 10298 } 10299 10300 for { 10301 t, done, err := decoder.Token() 10302 if err != nil { 10303 return err 10304 } 10305 if done { 10306 break 10307 } 10308 originalDecoder := decoder 10309 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10310 switch { 10311 case strings.EqualFold("AccountId", t.Name.Local): 10312 val, err := decoder.Value() 10313 if err != nil { 10314 return err 10315 } 10316 if val == nil { 10317 break 10318 } 10319 { 10320 xtv := string(val) 10321 sv.AccountId = ptr.String(xtv) 10322 } 10323 10324 case strings.EqualFold("Arn", t.Name.Local): 10325 val, err := decoder.Value() 10326 if err != nil { 10327 return err 10328 } 10329 if val == nil { 10330 break 10331 } 10332 { 10333 xtv := string(val) 10334 sv.Arn = ptr.String(xtv) 10335 } 10336 10337 case strings.EqualFold("Encryption", t.Name.Local): 10338 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10339 if err := awsRestxml_deserializeDocumentStorageLensDataExportEncryption(&sv.Encryption, nodeDecoder); err != nil { 10340 return err 10341 } 10342 10343 case strings.EqualFold("Format", t.Name.Local): 10344 val, err := decoder.Value() 10345 if err != nil { 10346 return err 10347 } 10348 if val == nil { 10349 break 10350 } 10351 { 10352 xtv := string(val) 10353 sv.Format = types.Format(xtv) 10354 } 10355 10356 case strings.EqualFold("OutputSchemaVersion", t.Name.Local): 10357 val, err := decoder.Value() 10358 if err != nil { 10359 return err 10360 } 10361 if val == nil { 10362 break 10363 } 10364 { 10365 xtv := string(val) 10366 sv.OutputSchemaVersion = types.OutputSchemaVersion(xtv) 10367 } 10368 10369 case strings.EqualFold("Prefix", t.Name.Local): 10370 val, err := decoder.Value() 10371 if err != nil { 10372 return err 10373 } 10374 if val == nil { 10375 break 10376 } 10377 { 10378 xtv := string(val) 10379 sv.Prefix = ptr.String(xtv) 10380 } 10381 10382 default: 10383 // Do nothing and ignore the unexpected tag element 10384 err = decoder.Decoder.Skip() 10385 if err != nil { 10386 return err 10387 } 10388 10389 } 10390 decoder = originalDecoder 10391 } 10392 *v = sv 10393 return nil 10394} 10395 10396func awsRestxml_deserializeDocumentS3CopyObjectOperation(v **types.S3CopyObjectOperation, decoder smithyxml.NodeDecoder) error { 10397 if v == nil { 10398 return fmt.Errorf("unexpected nil of type %T", v) 10399 } 10400 var sv *types.S3CopyObjectOperation 10401 if *v == nil { 10402 sv = &types.S3CopyObjectOperation{} 10403 } else { 10404 sv = *v 10405 } 10406 10407 for { 10408 t, done, err := decoder.Token() 10409 if err != nil { 10410 return err 10411 } 10412 if done { 10413 break 10414 } 10415 originalDecoder := decoder 10416 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10417 switch { 10418 case strings.EqualFold("AccessControlGrants", t.Name.Local): 10419 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10420 if err := awsRestxml_deserializeDocumentS3GrantList(&sv.AccessControlGrants, nodeDecoder); err != nil { 10421 return err 10422 } 10423 10424 case strings.EqualFold("CannedAccessControlList", t.Name.Local): 10425 val, err := decoder.Value() 10426 if err != nil { 10427 return err 10428 } 10429 if val == nil { 10430 break 10431 } 10432 { 10433 xtv := string(val) 10434 sv.CannedAccessControlList = types.S3CannedAccessControlList(xtv) 10435 } 10436 10437 case strings.EqualFold("MetadataDirective", t.Name.Local): 10438 val, err := decoder.Value() 10439 if err != nil { 10440 return err 10441 } 10442 if val == nil { 10443 break 10444 } 10445 { 10446 xtv := string(val) 10447 sv.MetadataDirective = types.S3MetadataDirective(xtv) 10448 } 10449 10450 case strings.EqualFold("ModifiedSinceConstraint", t.Name.Local): 10451 val, err := decoder.Value() 10452 if err != nil { 10453 return err 10454 } 10455 if val == nil { 10456 break 10457 } 10458 { 10459 xtv := string(val) 10460 t, err := smithytime.ParseDateTime(xtv) 10461 if err != nil { 10462 return err 10463 } 10464 sv.ModifiedSinceConstraint = ptr.Time(t) 10465 } 10466 10467 case strings.EqualFold("NewObjectMetadata", t.Name.Local): 10468 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10469 if err := awsRestxml_deserializeDocumentS3ObjectMetadata(&sv.NewObjectMetadata, nodeDecoder); err != nil { 10470 return err 10471 } 10472 10473 case strings.EqualFold("NewObjectTagging", t.Name.Local): 10474 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10475 if err := awsRestxml_deserializeDocumentS3TagSet(&sv.NewObjectTagging, nodeDecoder); err != nil { 10476 return err 10477 } 10478 10479 case strings.EqualFold("ObjectLockLegalHoldStatus", t.Name.Local): 10480 val, err := decoder.Value() 10481 if err != nil { 10482 return err 10483 } 10484 if val == nil { 10485 break 10486 } 10487 { 10488 xtv := string(val) 10489 sv.ObjectLockLegalHoldStatus = types.S3ObjectLockLegalHoldStatus(xtv) 10490 } 10491 10492 case strings.EqualFold("ObjectLockMode", t.Name.Local): 10493 val, err := decoder.Value() 10494 if err != nil { 10495 return err 10496 } 10497 if val == nil { 10498 break 10499 } 10500 { 10501 xtv := string(val) 10502 sv.ObjectLockMode = types.S3ObjectLockMode(xtv) 10503 } 10504 10505 case strings.EqualFold("ObjectLockRetainUntilDate", t.Name.Local): 10506 val, err := decoder.Value() 10507 if err != nil { 10508 return err 10509 } 10510 if val == nil { 10511 break 10512 } 10513 { 10514 xtv := string(val) 10515 t, err := smithytime.ParseDateTime(xtv) 10516 if err != nil { 10517 return err 10518 } 10519 sv.ObjectLockRetainUntilDate = ptr.Time(t) 10520 } 10521 10522 case strings.EqualFold("RedirectLocation", t.Name.Local): 10523 val, err := decoder.Value() 10524 if err != nil { 10525 return err 10526 } 10527 if val == nil { 10528 break 10529 } 10530 { 10531 xtv := string(val) 10532 sv.RedirectLocation = ptr.String(xtv) 10533 } 10534 10535 case strings.EqualFold("RequesterPays", t.Name.Local): 10536 val, err := decoder.Value() 10537 if err != nil { 10538 return err 10539 } 10540 if val == nil { 10541 break 10542 } 10543 { 10544 xtv, err := strconv.ParseBool(string(val)) 10545 if err != nil { 10546 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 10547 } 10548 sv.RequesterPays = xtv 10549 } 10550 10551 case strings.EqualFold("SSEAwsKmsKeyId", t.Name.Local): 10552 val, err := decoder.Value() 10553 if err != nil { 10554 return err 10555 } 10556 if val == nil { 10557 break 10558 } 10559 { 10560 xtv := string(val) 10561 sv.SSEAwsKmsKeyId = ptr.String(xtv) 10562 } 10563 10564 case strings.EqualFold("StorageClass", t.Name.Local): 10565 val, err := decoder.Value() 10566 if err != nil { 10567 return err 10568 } 10569 if val == nil { 10570 break 10571 } 10572 { 10573 xtv := string(val) 10574 sv.StorageClass = types.S3StorageClass(xtv) 10575 } 10576 10577 case strings.EqualFold("TargetKeyPrefix", t.Name.Local): 10578 val, err := decoder.Value() 10579 if err != nil { 10580 return err 10581 } 10582 if val == nil { 10583 break 10584 } 10585 { 10586 xtv := string(val) 10587 sv.TargetKeyPrefix = ptr.String(xtv) 10588 } 10589 10590 case strings.EqualFold("TargetResource", t.Name.Local): 10591 val, err := decoder.Value() 10592 if err != nil { 10593 return err 10594 } 10595 if val == nil { 10596 break 10597 } 10598 { 10599 xtv := string(val) 10600 sv.TargetResource = ptr.String(xtv) 10601 } 10602 10603 case strings.EqualFold("UnModifiedSinceConstraint", t.Name.Local): 10604 val, err := decoder.Value() 10605 if err != nil { 10606 return err 10607 } 10608 if val == nil { 10609 break 10610 } 10611 { 10612 xtv := string(val) 10613 t, err := smithytime.ParseDateTime(xtv) 10614 if err != nil { 10615 return err 10616 } 10617 sv.UnModifiedSinceConstraint = ptr.Time(t) 10618 } 10619 10620 default: 10621 // Do nothing and ignore the unexpected tag element 10622 err = decoder.Decoder.Skip() 10623 if err != nil { 10624 return err 10625 } 10626 10627 } 10628 decoder = originalDecoder 10629 } 10630 *v = sv 10631 return nil 10632} 10633 10634func awsRestxml_deserializeDocumentS3DeleteObjectTaggingOperation(v **types.S3DeleteObjectTaggingOperation, decoder smithyxml.NodeDecoder) error { 10635 if v == nil { 10636 return fmt.Errorf("unexpected nil of type %T", v) 10637 } 10638 var sv *types.S3DeleteObjectTaggingOperation 10639 if *v == nil { 10640 sv = &types.S3DeleteObjectTaggingOperation{} 10641 } else { 10642 sv = *v 10643 } 10644 10645 for { 10646 t, done, err := decoder.Token() 10647 if err != nil { 10648 return err 10649 } 10650 if done { 10651 break 10652 } 10653 originalDecoder := decoder 10654 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10655 switch { 10656 default: 10657 // Do nothing and ignore the unexpected tag element 10658 err = decoder.Decoder.Skip() 10659 if err != nil { 10660 return err 10661 } 10662 10663 } 10664 decoder = originalDecoder 10665 } 10666 *v = sv 10667 return nil 10668} 10669 10670func awsRestxml_deserializeDocumentS3Grant(v **types.S3Grant, decoder smithyxml.NodeDecoder) error { 10671 if v == nil { 10672 return fmt.Errorf("unexpected nil of type %T", v) 10673 } 10674 var sv *types.S3Grant 10675 if *v == nil { 10676 sv = &types.S3Grant{} 10677 } else { 10678 sv = *v 10679 } 10680 10681 for { 10682 t, done, err := decoder.Token() 10683 if err != nil { 10684 return err 10685 } 10686 if done { 10687 break 10688 } 10689 originalDecoder := decoder 10690 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10691 switch { 10692 case strings.EqualFold("Grantee", t.Name.Local): 10693 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10694 if err := awsRestxml_deserializeDocumentS3Grantee(&sv.Grantee, nodeDecoder); err != nil { 10695 return err 10696 } 10697 10698 case strings.EqualFold("Permission", t.Name.Local): 10699 val, err := decoder.Value() 10700 if err != nil { 10701 return err 10702 } 10703 if val == nil { 10704 break 10705 } 10706 { 10707 xtv := string(val) 10708 sv.Permission = types.S3Permission(xtv) 10709 } 10710 10711 default: 10712 // Do nothing and ignore the unexpected tag element 10713 err = decoder.Decoder.Skip() 10714 if err != nil { 10715 return err 10716 } 10717 10718 } 10719 decoder = originalDecoder 10720 } 10721 *v = sv 10722 return nil 10723} 10724 10725func awsRestxml_deserializeDocumentS3Grantee(v **types.S3Grantee, decoder smithyxml.NodeDecoder) error { 10726 if v == nil { 10727 return fmt.Errorf("unexpected nil of type %T", v) 10728 } 10729 var sv *types.S3Grantee 10730 if *v == nil { 10731 sv = &types.S3Grantee{} 10732 } else { 10733 sv = *v 10734 } 10735 10736 for { 10737 t, done, err := decoder.Token() 10738 if err != nil { 10739 return err 10740 } 10741 if done { 10742 break 10743 } 10744 originalDecoder := decoder 10745 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10746 switch { 10747 case strings.EqualFold("DisplayName", t.Name.Local): 10748 val, err := decoder.Value() 10749 if err != nil { 10750 return err 10751 } 10752 if val == nil { 10753 break 10754 } 10755 { 10756 xtv := string(val) 10757 sv.DisplayName = ptr.String(xtv) 10758 } 10759 10760 case strings.EqualFold("Identifier", t.Name.Local): 10761 val, err := decoder.Value() 10762 if err != nil { 10763 return err 10764 } 10765 if val == nil { 10766 break 10767 } 10768 { 10769 xtv := string(val) 10770 sv.Identifier = ptr.String(xtv) 10771 } 10772 10773 case strings.EqualFold("TypeIdentifier", t.Name.Local): 10774 val, err := decoder.Value() 10775 if err != nil { 10776 return err 10777 } 10778 if val == nil { 10779 break 10780 } 10781 { 10782 xtv := string(val) 10783 sv.TypeIdentifier = types.S3GranteeTypeIdentifier(xtv) 10784 } 10785 10786 default: 10787 // Do nothing and ignore the unexpected tag element 10788 err = decoder.Decoder.Skip() 10789 if err != nil { 10790 return err 10791 } 10792 10793 } 10794 decoder = originalDecoder 10795 } 10796 *v = sv 10797 return nil 10798} 10799 10800func awsRestxml_deserializeDocumentS3GrantList(v *[]types.S3Grant, decoder smithyxml.NodeDecoder) error { 10801 if v == nil { 10802 return fmt.Errorf("unexpected nil of type %T", v) 10803 } 10804 var sv []types.S3Grant 10805 if *v == nil { 10806 sv = make([]types.S3Grant, 0) 10807 } else { 10808 sv = *v 10809 } 10810 10811 originalDecoder := decoder 10812 for { 10813 t, done, err := decoder.Token() 10814 if err != nil { 10815 return err 10816 } 10817 if done { 10818 break 10819 } 10820 switch { 10821 case strings.EqualFold("member", t.Name.Local): 10822 var col types.S3Grant 10823 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10824 destAddr := &col 10825 if err := awsRestxml_deserializeDocumentS3Grant(&destAddr, nodeDecoder); err != nil { 10826 return err 10827 } 10828 col = *destAddr 10829 sv = append(sv, col) 10830 10831 default: 10832 err = decoder.Decoder.Skip() 10833 if err != nil { 10834 return err 10835 } 10836 10837 } 10838 decoder = originalDecoder 10839 } 10840 *v = sv 10841 return nil 10842} 10843 10844func awsRestxml_deserializeDocumentS3GrantListUnwrapped(v *[]types.S3Grant, decoder smithyxml.NodeDecoder) error { 10845 var sv []types.S3Grant 10846 if *v == nil { 10847 sv = make([]types.S3Grant, 0) 10848 } else { 10849 sv = *v 10850 } 10851 10852 switch { 10853 default: 10854 var mv types.S3Grant 10855 t := decoder.StartEl 10856 _ = t 10857 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10858 destAddr := &mv 10859 if err := awsRestxml_deserializeDocumentS3Grant(&destAddr, nodeDecoder); err != nil { 10860 return err 10861 } 10862 mv = *destAddr 10863 sv = append(sv, mv) 10864 } 10865 *v = sv 10866 return nil 10867} 10868func awsRestxml_deserializeDocumentS3InitiateRestoreObjectOperation(v **types.S3InitiateRestoreObjectOperation, decoder smithyxml.NodeDecoder) error { 10869 if v == nil { 10870 return fmt.Errorf("unexpected nil of type %T", v) 10871 } 10872 var sv *types.S3InitiateRestoreObjectOperation 10873 if *v == nil { 10874 sv = &types.S3InitiateRestoreObjectOperation{} 10875 } else { 10876 sv = *v 10877 } 10878 10879 for { 10880 t, done, err := decoder.Token() 10881 if err != nil { 10882 return err 10883 } 10884 if done { 10885 break 10886 } 10887 originalDecoder := decoder 10888 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10889 switch { 10890 case strings.EqualFold("ExpirationInDays", t.Name.Local): 10891 val, err := decoder.Value() 10892 if err != nil { 10893 return err 10894 } 10895 if val == nil { 10896 break 10897 } 10898 { 10899 xtv := string(val) 10900 i64, err := strconv.ParseInt(xtv, 10, 64) 10901 if err != nil { 10902 return err 10903 } 10904 sv.ExpirationInDays = ptr.Int32(int32(i64)) 10905 } 10906 10907 case strings.EqualFold("GlacierJobTier", t.Name.Local): 10908 val, err := decoder.Value() 10909 if err != nil { 10910 return err 10911 } 10912 if val == nil { 10913 break 10914 } 10915 { 10916 xtv := string(val) 10917 sv.GlacierJobTier = types.S3GlacierJobTier(xtv) 10918 } 10919 10920 default: 10921 // Do nothing and ignore the unexpected tag element 10922 err = decoder.Decoder.Skip() 10923 if err != nil { 10924 return err 10925 } 10926 10927 } 10928 decoder = originalDecoder 10929 } 10930 *v = sv 10931 return nil 10932} 10933 10934func awsRestxml_deserializeDocumentS3ObjectLockLegalHold(v **types.S3ObjectLockLegalHold, decoder smithyxml.NodeDecoder) error { 10935 if v == nil { 10936 return fmt.Errorf("unexpected nil of type %T", v) 10937 } 10938 var sv *types.S3ObjectLockLegalHold 10939 if *v == nil { 10940 sv = &types.S3ObjectLockLegalHold{} 10941 } else { 10942 sv = *v 10943 } 10944 10945 for { 10946 t, done, err := decoder.Token() 10947 if err != nil { 10948 return err 10949 } 10950 if done { 10951 break 10952 } 10953 originalDecoder := decoder 10954 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10955 switch { 10956 case strings.EqualFold("Status", t.Name.Local): 10957 val, err := decoder.Value() 10958 if err != nil { 10959 return err 10960 } 10961 if val == nil { 10962 break 10963 } 10964 { 10965 xtv := string(val) 10966 sv.Status = types.S3ObjectLockLegalHoldStatus(xtv) 10967 } 10968 10969 default: 10970 // Do nothing and ignore the unexpected tag element 10971 err = decoder.Decoder.Skip() 10972 if err != nil { 10973 return err 10974 } 10975 10976 } 10977 decoder = originalDecoder 10978 } 10979 *v = sv 10980 return nil 10981} 10982 10983func awsRestxml_deserializeDocumentS3ObjectMetadata(v **types.S3ObjectMetadata, decoder smithyxml.NodeDecoder) error { 10984 if v == nil { 10985 return fmt.Errorf("unexpected nil of type %T", v) 10986 } 10987 var sv *types.S3ObjectMetadata 10988 if *v == nil { 10989 sv = &types.S3ObjectMetadata{} 10990 } else { 10991 sv = *v 10992 } 10993 10994 for { 10995 t, done, err := decoder.Token() 10996 if err != nil { 10997 return err 10998 } 10999 if done { 11000 break 11001 } 11002 originalDecoder := decoder 11003 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11004 switch { 11005 case strings.EqualFold("CacheControl", t.Name.Local): 11006 val, err := decoder.Value() 11007 if err != nil { 11008 return err 11009 } 11010 if val == nil { 11011 break 11012 } 11013 { 11014 xtv := string(val) 11015 sv.CacheControl = ptr.String(xtv) 11016 } 11017 11018 case strings.EqualFold("ContentDisposition", t.Name.Local): 11019 val, err := decoder.Value() 11020 if err != nil { 11021 return err 11022 } 11023 if val == nil { 11024 break 11025 } 11026 { 11027 xtv := string(val) 11028 sv.ContentDisposition = ptr.String(xtv) 11029 } 11030 11031 case strings.EqualFold("ContentEncoding", t.Name.Local): 11032 val, err := decoder.Value() 11033 if err != nil { 11034 return err 11035 } 11036 if val == nil { 11037 break 11038 } 11039 { 11040 xtv := string(val) 11041 sv.ContentEncoding = ptr.String(xtv) 11042 } 11043 11044 case strings.EqualFold("ContentLanguage", t.Name.Local): 11045 val, err := decoder.Value() 11046 if err != nil { 11047 return err 11048 } 11049 if val == nil { 11050 break 11051 } 11052 { 11053 xtv := string(val) 11054 sv.ContentLanguage = ptr.String(xtv) 11055 } 11056 11057 case strings.EqualFold("ContentLength", t.Name.Local): 11058 val, err := decoder.Value() 11059 if err != nil { 11060 return err 11061 } 11062 if val == nil { 11063 break 11064 } 11065 { 11066 xtv := string(val) 11067 i64, err := strconv.ParseInt(xtv, 10, 64) 11068 if err != nil { 11069 return err 11070 } 11071 sv.ContentLength = i64 11072 } 11073 11074 case strings.EqualFold("ContentMD5", t.Name.Local): 11075 val, err := decoder.Value() 11076 if err != nil { 11077 return err 11078 } 11079 if val == nil { 11080 break 11081 } 11082 { 11083 xtv := string(val) 11084 sv.ContentMD5 = ptr.String(xtv) 11085 } 11086 11087 case strings.EqualFold("ContentType", t.Name.Local): 11088 val, err := decoder.Value() 11089 if err != nil { 11090 return err 11091 } 11092 if val == nil { 11093 break 11094 } 11095 { 11096 xtv := string(val) 11097 sv.ContentType = ptr.String(xtv) 11098 } 11099 11100 case strings.EqualFold("HttpExpiresDate", t.Name.Local): 11101 val, err := decoder.Value() 11102 if err != nil { 11103 return err 11104 } 11105 if val == nil { 11106 break 11107 } 11108 { 11109 xtv := string(val) 11110 t, err := smithytime.ParseDateTime(xtv) 11111 if err != nil { 11112 return err 11113 } 11114 sv.HttpExpiresDate = ptr.Time(t) 11115 } 11116 11117 case strings.EqualFold("RequesterCharged", t.Name.Local): 11118 val, err := decoder.Value() 11119 if err != nil { 11120 return err 11121 } 11122 if val == nil { 11123 break 11124 } 11125 { 11126 xtv, err := strconv.ParseBool(string(val)) 11127 if err != nil { 11128 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 11129 } 11130 sv.RequesterCharged = xtv 11131 } 11132 11133 case strings.EqualFold("SSEAlgorithm", t.Name.Local): 11134 val, err := decoder.Value() 11135 if err != nil { 11136 return err 11137 } 11138 if val == nil { 11139 break 11140 } 11141 { 11142 xtv := string(val) 11143 sv.SSEAlgorithm = types.S3SSEAlgorithm(xtv) 11144 } 11145 11146 case strings.EqualFold("UserMetadata", t.Name.Local): 11147 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11148 if err := awsRestxml_deserializeDocumentS3UserMetadata(&sv.UserMetadata, nodeDecoder); err != nil { 11149 return err 11150 } 11151 11152 default: 11153 // Do nothing and ignore the unexpected tag element 11154 err = decoder.Decoder.Skip() 11155 if err != nil { 11156 return err 11157 } 11158 11159 } 11160 decoder = originalDecoder 11161 } 11162 *v = sv 11163 return nil 11164} 11165 11166func awsRestxml_deserializeDocumentS3ObjectOwner(v **types.S3ObjectOwner, decoder smithyxml.NodeDecoder) error { 11167 if v == nil { 11168 return fmt.Errorf("unexpected nil of type %T", v) 11169 } 11170 var sv *types.S3ObjectOwner 11171 if *v == nil { 11172 sv = &types.S3ObjectOwner{} 11173 } else { 11174 sv = *v 11175 } 11176 11177 for { 11178 t, done, err := decoder.Token() 11179 if err != nil { 11180 return err 11181 } 11182 if done { 11183 break 11184 } 11185 originalDecoder := decoder 11186 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11187 switch { 11188 case strings.EqualFold("DisplayName", t.Name.Local): 11189 val, err := decoder.Value() 11190 if err != nil { 11191 return err 11192 } 11193 if val == nil { 11194 break 11195 } 11196 { 11197 xtv := string(val) 11198 sv.DisplayName = ptr.String(xtv) 11199 } 11200 11201 case strings.EqualFold("ID", t.Name.Local): 11202 val, err := decoder.Value() 11203 if err != nil { 11204 return err 11205 } 11206 if val == nil { 11207 break 11208 } 11209 { 11210 xtv := string(val) 11211 sv.ID = ptr.String(xtv) 11212 } 11213 11214 default: 11215 // Do nothing and ignore the unexpected tag element 11216 err = decoder.Decoder.Skip() 11217 if err != nil { 11218 return err 11219 } 11220 11221 } 11222 decoder = originalDecoder 11223 } 11224 *v = sv 11225 return nil 11226} 11227 11228func awsRestxml_deserializeDocumentS3Retention(v **types.S3Retention, decoder smithyxml.NodeDecoder) error { 11229 if v == nil { 11230 return fmt.Errorf("unexpected nil of type %T", v) 11231 } 11232 var sv *types.S3Retention 11233 if *v == nil { 11234 sv = &types.S3Retention{} 11235 } else { 11236 sv = *v 11237 } 11238 11239 for { 11240 t, done, err := decoder.Token() 11241 if err != nil { 11242 return err 11243 } 11244 if done { 11245 break 11246 } 11247 originalDecoder := decoder 11248 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11249 switch { 11250 case strings.EqualFold("Mode", t.Name.Local): 11251 val, err := decoder.Value() 11252 if err != nil { 11253 return err 11254 } 11255 if val == nil { 11256 break 11257 } 11258 { 11259 xtv := string(val) 11260 sv.Mode = types.S3ObjectLockRetentionMode(xtv) 11261 } 11262 11263 case strings.EqualFold("RetainUntilDate", t.Name.Local): 11264 val, err := decoder.Value() 11265 if err != nil { 11266 return err 11267 } 11268 if val == nil { 11269 break 11270 } 11271 { 11272 xtv := string(val) 11273 t, err := smithytime.ParseDateTime(xtv) 11274 if err != nil { 11275 return err 11276 } 11277 sv.RetainUntilDate = ptr.Time(t) 11278 } 11279 11280 default: 11281 // Do nothing and ignore the unexpected tag element 11282 err = decoder.Decoder.Skip() 11283 if err != nil { 11284 return err 11285 } 11286 11287 } 11288 decoder = originalDecoder 11289 } 11290 *v = sv 11291 return nil 11292} 11293 11294func awsRestxml_deserializeDocumentS3SetObjectAclOperation(v **types.S3SetObjectAclOperation, decoder smithyxml.NodeDecoder) error { 11295 if v == nil { 11296 return fmt.Errorf("unexpected nil of type %T", v) 11297 } 11298 var sv *types.S3SetObjectAclOperation 11299 if *v == nil { 11300 sv = &types.S3SetObjectAclOperation{} 11301 } else { 11302 sv = *v 11303 } 11304 11305 for { 11306 t, done, err := decoder.Token() 11307 if err != nil { 11308 return err 11309 } 11310 if done { 11311 break 11312 } 11313 originalDecoder := decoder 11314 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11315 switch { 11316 case strings.EqualFold("AccessControlPolicy", t.Name.Local): 11317 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11318 if err := awsRestxml_deserializeDocumentS3AccessControlPolicy(&sv.AccessControlPolicy, nodeDecoder); err != nil { 11319 return err 11320 } 11321 11322 default: 11323 // Do nothing and ignore the unexpected tag element 11324 err = decoder.Decoder.Skip() 11325 if err != nil { 11326 return err 11327 } 11328 11329 } 11330 decoder = originalDecoder 11331 } 11332 *v = sv 11333 return nil 11334} 11335 11336func awsRestxml_deserializeDocumentS3SetObjectLegalHoldOperation(v **types.S3SetObjectLegalHoldOperation, decoder smithyxml.NodeDecoder) error { 11337 if v == nil { 11338 return fmt.Errorf("unexpected nil of type %T", v) 11339 } 11340 var sv *types.S3SetObjectLegalHoldOperation 11341 if *v == nil { 11342 sv = &types.S3SetObjectLegalHoldOperation{} 11343 } else { 11344 sv = *v 11345 } 11346 11347 for { 11348 t, done, err := decoder.Token() 11349 if err != nil { 11350 return err 11351 } 11352 if done { 11353 break 11354 } 11355 originalDecoder := decoder 11356 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11357 switch { 11358 case strings.EqualFold("LegalHold", t.Name.Local): 11359 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11360 if err := awsRestxml_deserializeDocumentS3ObjectLockLegalHold(&sv.LegalHold, nodeDecoder); err != nil { 11361 return err 11362 } 11363 11364 default: 11365 // Do nothing and ignore the unexpected tag element 11366 err = decoder.Decoder.Skip() 11367 if err != nil { 11368 return err 11369 } 11370 11371 } 11372 decoder = originalDecoder 11373 } 11374 *v = sv 11375 return nil 11376} 11377 11378func awsRestxml_deserializeDocumentS3SetObjectRetentionOperation(v **types.S3SetObjectRetentionOperation, decoder smithyxml.NodeDecoder) error { 11379 if v == nil { 11380 return fmt.Errorf("unexpected nil of type %T", v) 11381 } 11382 var sv *types.S3SetObjectRetentionOperation 11383 if *v == nil { 11384 sv = &types.S3SetObjectRetentionOperation{} 11385 } else { 11386 sv = *v 11387 } 11388 11389 for { 11390 t, done, err := decoder.Token() 11391 if err != nil { 11392 return err 11393 } 11394 if done { 11395 break 11396 } 11397 originalDecoder := decoder 11398 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11399 switch { 11400 case strings.EqualFold("BypassGovernanceRetention", t.Name.Local): 11401 val, err := decoder.Value() 11402 if err != nil { 11403 return err 11404 } 11405 if val == nil { 11406 break 11407 } 11408 { 11409 xtv, err := strconv.ParseBool(string(val)) 11410 if err != nil { 11411 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 11412 } 11413 sv.BypassGovernanceRetention = xtv 11414 } 11415 11416 case strings.EqualFold("Retention", t.Name.Local): 11417 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11418 if err := awsRestxml_deserializeDocumentS3Retention(&sv.Retention, nodeDecoder); err != nil { 11419 return err 11420 } 11421 11422 default: 11423 // Do nothing and ignore the unexpected tag element 11424 err = decoder.Decoder.Skip() 11425 if err != nil { 11426 return err 11427 } 11428 11429 } 11430 decoder = originalDecoder 11431 } 11432 *v = sv 11433 return nil 11434} 11435 11436func awsRestxml_deserializeDocumentS3SetObjectTaggingOperation(v **types.S3SetObjectTaggingOperation, decoder smithyxml.NodeDecoder) error { 11437 if v == nil { 11438 return fmt.Errorf("unexpected nil of type %T", v) 11439 } 11440 var sv *types.S3SetObjectTaggingOperation 11441 if *v == nil { 11442 sv = &types.S3SetObjectTaggingOperation{} 11443 } else { 11444 sv = *v 11445 } 11446 11447 for { 11448 t, done, err := decoder.Token() 11449 if err != nil { 11450 return err 11451 } 11452 if done { 11453 break 11454 } 11455 originalDecoder := decoder 11456 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11457 switch { 11458 case strings.EqualFold("TagSet", t.Name.Local): 11459 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11460 if err := awsRestxml_deserializeDocumentS3TagSet(&sv.TagSet, nodeDecoder); err != nil { 11461 return err 11462 } 11463 11464 default: 11465 // Do nothing and ignore the unexpected tag element 11466 err = decoder.Decoder.Skip() 11467 if err != nil { 11468 return err 11469 } 11470 11471 } 11472 decoder = originalDecoder 11473 } 11474 *v = sv 11475 return nil 11476} 11477 11478func awsRestxml_deserializeDocumentS3Tag(v **types.S3Tag, decoder smithyxml.NodeDecoder) error { 11479 if v == nil { 11480 return fmt.Errorf("unexpected nil of type %T", v) 11481 } 11482 var sv *types.S3Tag 11483 if *v == nil { 11484 sv = &types.S3Tag{} 11485 } else { 11486 sv = *v 11487 } 11488 11489 for { 11490 t, done, err := decoder.Token() 11491 if err != nil { 11492 return err 11493 } 11494 if done { 11495 break 11496 } 11497 originalDecoder := decoder 11498 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11499 switch { 11500 case strings.EqualFold("Key", t.Name.Local): 11501 val, err := decoder.Value() 11502 if err != nil { 11503 return err 11504 } 11505 if val == nil { 11506 break 11507 } 11508 { 11509 xtv := string(val) 11510 sv.Key = ptr.String(xtv) 11511 } 11512 11513 case strings.EqualFold("Value", t.Name.Local): 11514 val, err := decoder.Value() 11515 if err != nil { 11516 return err 11517 } 11518 if val == nil { 11519 break 11520 } 11521 { 11522 xtv := string(val) 11523 sv.Value = ptr.String(xtv) 11524 } 11525 11526 default: 11527 // Do nothing and ignore the unexpected tag element 11528 err = decoder.Decoder.Skip() 11529 if err != nil { 11530 return err 11531 } 11532 11533 } 11534 decoder = originalDecoder 11535 } 11536 *v = sv 11537 return nil 11538} 11539 11540func awsRestxml_deserializeDocumentS3TagSet(v *[]types.S3Tag, decoder smithyxml.NodeDecoder) error { 11541 if v == nil { 11542 return fmt.Errorf("unexpected nil of type %T", v) 11543 } 11544 var sv []types.S3Tag 11545 if *v == nil { 11546 sv = make([]types.S3Tag, 0) 11547 } else { 11548 sv = *v 11549 } 11550 11551 originalDecoder := decoder 11552 for { 11553 t, done, err := decoder.Token() 11554 if err != nil { 11555 return err 11556 } 11557 if done { 11558 break 11559 } 11560 switch { 11561 case strings.EqualFold("member", t.Name.Local): 11562 var col types.S3Tag 11563 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11564 destAddr := &col 11565 if err := awsRestxml_deserializeDocumentS3Tag(&destAddr, nodeDecoder); err != nil { 11566 return err 11567 } 11568 col = *destAddr 11569 sv = append(sv, col) 11570 11571 default: 11572 err = decoder.Decoder.Skip() 11573 if err != nil { 11574 return err 11575 } 11576 11577 } 11578 decoder = originalDecoder 11579 } 11580 *v = sv 11581 return nil 11582} 11583 11584func awsRestxml_deserializeDocumentS3TagSetUnwrapped(v *[]types.S3Tag, decoder smithyxml.NodeDecoder) error { 11585 var sv []types.S3Tag 11586 if *v == nil { 11587 sv = make([]types.S3Tag, 0) 11588 } else { 11589 sv = *v 11590 } 11591 11592 switch { 11593 default: 11594 var mv types.S3Tag 11595 t := decoder.StartEl 11596 _ = t 11597 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11598 destAddr := &mv 11599 if err := awsRestxml_deserializeDocumentS3Tag(&destAddr, nodeDecoder); err != nil { 11600 return err 11601 } 11602 mv = *destAddr 11603 sv = append(sv, mv) 11604 } 11605 *v = sv 11606 return nil 11607} 11608func awsRestxml_deserializeDocumentS3UserMetadata(v *map[string]string, decoder smithyxml.NodeDecoder) error { 11609 if v == nil { 11610 return fmt.Errorf("unexpected nil of type %T", v) 11611 } 11612 var sv map[string]string 11613 if *v == nil { 11614 sv = make(map[string]string, 0) 11615 } else { 11616 sv = *v 11617 } 11618 11619 for { 11620 t, done, err := decoder.Token() 11621 if err != nil { 11622 return err 11623 } 11624 if done { 11625 break 11626 } 11627 switch { 11628 case strings.EqualFold("entry", t.Name.Local): 11629 entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11630 if err := awsRestxml_deserializeDocumentS3UserMetadataUnwrapped(&sv, entryDecoder); err != nil { 11631 return err 11632 } 11633 11634 default: 11635 err = decoder.Decoder.Skip() 11636 if err != nil { 11637 return err 11638 } 11639 11640 } 11641 } 11642 *v = sv 11643 return nil 11644} 11645 11646func awsRestxml_deserializeDocumentS3UserMetadataUnwrapped(v *map[string]string, decoder smithyxml.NodeDecoder) error { 11647 var sv map[string]string 11648 if *v == nil { 11649 sv = make(map[string]string, 0) 11650 } else { 11651 sv = *v 11652 } 11653 11654 var ek string 11655 var ev string 11656 for { 11657 t, done, err := decoder.Token() 11658 if err != nil { 11659 return err 11660 } 11661 if done { 11662 sv[ek] = ev 11663 break 11664 } 11665 originalDecoder := decoder 11666 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11667 switch { 11668 case strings.EqualFold("key", t.Name.Local): 11669 val, err := decoder.Value() 11670 if err != nil { 11671 return err 11672 } 11673 if val == nil { 11674 break 11675 } 11676 { 11677 xtv := string(val) 11678 ek = xtv 11679 } 11680 11681 case strings.EqualFold("value", t.Name.Local): 11682 val, err := decoder.Value() 11683 if err != nil { 11684 return err 11685 } 11686 if val == nil { 11687 break 11688 } 11689 { 11690 xtv := string(val) 11691 ev = xtv 11692 } 11693 11694 default: 11695 err = decoder.Decoder.Skip() 11696 if err != nil { 11697 return err 11698 } 11699 11700 } 11701 decoder = originalDecoder 11702 } 11703 *v = sv 11704 return nil 11705} 11706func awsRestxml_deserializeDocumentSelectionCriteria(v **types.SelectionCriteria, decoder smithyxml.NodeDecoder) error { 11707 if v == nil { 11708 return fmt.Errorf("unexpected nil of type %T", v) 11709 } 11710 var sv *types.SelectionCriteria 11711 if *v == nil { 11712 sv = &types.SelectionCriteria{} 11713 } else { 11714 sv = *v 11715 } 11716 11717 for { 11718 t, done, err := decoder.Token() 11719 if err != nil { 11720 return err 11721 } 11722 if done { 11723 break 11724 } 11725 originalDecoder := decoder 11726 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11727 switch { 11728 case strings.EqualFold("Delimiter", t.Name.Local): 11729 val, err := decoder.Value() 11730 if err != nil { 11731 return err 11732 } 11733 if val == nil { 11734 break 11735 } 11736 { 11737 xtv := string(val) 11738 sv.Delimiter = ptr.String(xtv) 11739 } 11740 11741 case strings.EqualFold("MaxDepth", t.Name.Local): 11742 val, err := decoder.Value() 11743 if err != nil { 11744 return err 11745 } 11746 if val == nil { 11747 break 11748 } 11749 { 11750 xtv := string(val) 11751 i64, err := strconv.ParseInt(xtv, 10, 64) 11752 if err != nil { 11753 return err 11754 } 11755 sv.MaxDepth = int32(i64) 11756 } 11757 11758 case strings.EqualFold("MinStorageBytesPercentage", t.Name.Local): 11759 val, err := decoder.Value() 11760 if err != nil { 11761 return err 11762 } 11763 if val == nil { 11764 break 11765 } 11766 { 11767 xtv := string(val) 11768 f64, err := strconv.ParseFloat(xtv, 64) 11769 if err != nil { 11770 return err 11771 } 11772 sv.MinStorageBytesPercentage = f64 11773 } 11774 11775 default: 11776 // Do nothing and ignore the unexpected tag element 11777 err = decoder.Decoder.Skip() 11778 if err != nil { 11779 return err 11780 } 11781 11782 } 11783 decoder = originalDecoder 11784 } 11785 *v = sv 11786 return nil 11787} 11788 11789func awsRestxml_deserializeDocumentSSEKMS(v **types.SSEKMS, decoder smithyxml.NodeDecoder) error { 11790 if v == nil { 11791 return fmt.Errorf("unexpected nil of type %T", v) 11792 } 11793 var sv *types.SSEKMS 11794 if *v == nil { 11795 sv = &types.SSEKMS{} 11796 } else { 11797 sv = *v 11798 } 11799 11800 for { 11801 t, done, err := decoder.Token() 11802 if err != nil { 11803 return err 11804 } 11805 if done { 11806 break 11807 } 11808 originalDecoder := decoder 11809 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11810 switch { 11811 case strings.EqualFold("KeyId", t.Name.Local): 11812 val, err := decoder.Value() 11813 if err != nil { 11814 return err 11815 } 11816 if val == nil { 11817 break 11818 } 11819 { 11820 xtv := string(val) 11821 sv.KeyId = ptr.String(xtv) 11822 } 11823 11824 default: 11825 // Do nothing and ignore the unexpected tag element 11826 err = decoder.Decoder.Skip() 11827 if err != nil { 11828 return err 11829 } 11830 11831 } 11832 decoder = originalDecoder 11833 } 11834 *v = sv 11835 return nil 11836} 11837 11838func awsRestxml_deserializeDocumentSSES3(v **types.SSES3, decoder smithyxml.NodeDecoder) error { 11839 if v == nil { 11840 return fmt.Errorf("unexpected nil of type %T", v) 11841 } 11842 var sv *types.SSES3 11843 if *v == nil { 11844 sv = &types.SSES3{} 11845 } else { 11846 sv = *v 11847 } 11848 11849 for { 11850 t, done, err := decoder.Token() 11851 if err != nil { 11852 return err 11853 } 11854 if done { 11855 break 11856 } 11857 originalDecoder := decoder 11858 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11859 switch { 11860 default: 11861 // Do nothing and ignore the unexpected tag element 11862 err = decoder.Decoder.Skip() 11863 if err != nil { 11864 return err 11865 } 11866 11867 } 11868 decoder = originalDecoder 11869 } 11870 *v = sv 11871 return nil 11872} 11873 11874func awsRestxml_deserializeDocumentStorageLensAwsOrg(v **types.StorageLensAwsOrg, decoder smithyxml.NodeDecoder) error { 11875 if v == nil { 11876 return fmt.Errorf("unexpected nil of type %T", v) 11877 } 11878 var sv *types.StorageLensAwsOrg 11879 if *v == nil { 11880 sv = &types.StorageLensAwsOrg{} 11881 } else { 11882 sv = *v 11883 } 11884 11885 for { 11886 t, done, err := decoder.Token() 11887 if err != nil { 11888 return err 11889 } 11890 if done { 11891 break 11892 } 11893 originalDecoder := decoder 11894 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11895 switch { 11896 case strings.EqualFold("Arn", t.Name.Local): 11897 val, err := decoder.Value() 11898 if err != nil { 11899 return err 11900 } 11901 if val == nil { 11902 break 11903 } 11904 { 11905 xtv := string(val) 11906 sv.Arn = ptr.String(xtv) 11907 } 11908 11909 default: 11910 // Do nothing and ignore the unexpected tag element 11911 err = decoder.Decoder.Skip() 11912 if err != nil { 11913 return err 11914 } 11915 11916 } 11917 decoder = originalDecoder 11918 } 11919 *v = sv 11920 return nil 11921} 11922 11923func awsRestxml_deserializeDocumentStorageLensConfiguration(v **types.StorageLensConfiguration, decoder smithyxml.NodeDecoder) error { 11924 if v == nil { 11925 return fmt.Errorf("unexpected nil of type %T", v) 11926 } 11927 var sv *types.StorageLensConfiguration 11928 if *v == nil { 11929 sv = &types.StorageLensConfiguration{} 11930 } else { 11931 sv = *v 11932 } 11933 11934 for { 11935 t, done, err := decoder.Token() 11936 if err != nil { 11937 return err 11938 } 11939 if done { 11940 break 11941 } 11942 originalDecoder := decoder 11943 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11944 switch { 11945 case strings.EqualFold("AccountLevel", t.Name.Local): 11946 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11947 if err := awsRestxml_deserializeDocumentAccountLevel(&sv.AccountLevel, nodeDecoder); err != nil { 11948 return err 11949 } 11950 11951 case strings.EqualFold("AwsOrg", t.Name.Local): 11952 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11953 if err := awsRestxml_deserializeDocumentStorageLensAwsOrg(&sv.AwsOrg, nodeDecoder); err != nil { 11954 return err 11955 } 11956 11957 case strings.EqualFold("DataExport", t.Name.Local): 11958 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11959 if err := awsRestxml_deserializeDocumentStorageLensDataExport(&sv.DataExport, nodeDecoder); err != nil { 11960 return err 11961 } 11962 11963 case strings.EqualFold("Exclude", t.Name.Local): 11964 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11965 if err := awsRestxml_deserializeDocumentExclude(&sv.Exclude, nodeDecoder); err != nil { 11966 return err 11967 } 11968 11969 case strings.EqualFold("Id", t.Name.Local): 11970 val, err := decoder.Value() 11971 if err != nil { 11972 return err 11973 } 11974 if val == nil { 11975 break 11976 } 11977 { 11978 xtv := string(val) 11979 sv.Id = ptr.String(xtv) 11980 } 11981 11982 case strings.EqualFold("Include", t.Name.Local): 11983 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11984 if err := awsRestxml_deserializeDocumentInclude(&sv.Include, nodeDecoder); err != nil { 11985 return err 11986 } 11987 11988 case strings.EqualFold("IsEnabled", t.Name.Local): 11989 val, err := decoder.Value() 11990 if err != nil { 11991 return err 11992 } 11993 if val == nil { 11994 break 11995 } 11996 { 11997 xtv, err := strconv.ParseBool(string(val)) 11998 if err != nil { 11999 return fmt.Errorf("expected IsEnabled to be of type *bool, got %T instead", val) 12000 } 12001 sv.IsEnabled = xtv 12002 } 12003 12004 case strings.EqualFold("StorageLensArn", t.Name.Local): 12005 val, err := decoder.Value() 12006 if err != nil { 12007 return err 12008 } 12009 if val == nil { 12010 break 12011 } 12012 { 12013 xtv := string(val) 12014 sv.StorageLensArn = ptr.String(xtv) 12015 } 12016 12017 default: 12018 // Do nothing and ignore the unexpected tag element 12019 err = decoder.Decoder.Skip() 12020 if err != nil { 12021 return err 12022 } 12023 12024 } 12025 decoder = originalDecoder 12026 } 12027 *v = sv 12028 return nil 12029} 12030 12031func awsRestxml_deserializeDocumentStorageLensConfigurationList(v *[]types.ListStorageLensConfigurationEntry, decoder smithyxml.NodeDecoder) error { 12032 if v == nil { 12033 return fmt.Errorf("unexpected nil of type %T", v) 12034 } 12035 var sv []types.ListStorageLensConfigurationEntry 12036 if *v == nil { 12037 sv = make([]types.ListStorageLensConfigurationEntry, 0) 12038 } else { 12039 sv = *v 12040 } 12041 12042 originalDecoder := decoder 12043 for { 12044 t, done, err := decoder.Token() 12045 if err != nil { 12046 return err 12047 } 12048 if done { 12049 break 12050 } 12051 switch { 12052 case strings.EqualFold("StorageLensConfiguration", t.Name.Local): 12053 var col types.ListStorageLensConfigurationEntry 12054 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12055 destAddr := &col 12056 if err := awsRestxml_deserializeDocumentListStorageLensConfigurationEntry(&destAddr, nodeDecoder); err != nil { 12057 return err 12058 } 12059 col = *destAddr 12060 sv = append(sv, col) 12061 12062 default: 12063 err = decoder.Decoder.Skip() 12064 if err != nil { 12065 return err 12066 } 12067 12068 } 12069 decoder = originalDecoder 12070 } 12071 *v = sv 12072 return nil 12073} 12074 12075func awsRestxml_deserializeDocumentStorageLensConfigurationListUnwrapped(v *[]types.ListStorageLensConfigurationEntry, decoder smithyxml.NodeDecoder) error { 12076 var sv []types.ListStorageLensConfigurationEntry 12077 if *v == nil { 12078 sv = make([]types.ListStorageLensConfigurationEntry, 0) 12079 } else { 12080 sv = *v 12081 } 12082 12083 switch { 12084 default: 12085 var mv types.ListStorageLensConfigurationEntry 12086 t := decoder.StartEl 12087 _ = t 12088 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12089 destAddr := &mv 12090 if err := awsRestxml_deserializeDocumentListStorageLensConfigurationEntry(&destAddr, nodeDecoder); err != nil { 12091 return err 12092 } 12093 mv = *destAddr 12094 sv = append(sv, mv) 12095 } 12096 *v = sv 12097 return nil 12098} 12099func awsRestxml_deserializeDocumentStorageLensDataExport(v **types.StorageLensDataExport, decoder smithyxml.NodeDecoder) error { 12100 if v == nil { 12101 return fmt.Errorf("unexpected nil of type %T", v) 12102 } 12103 var sv *types.StorageLensDataExport 12104 if *v == nil { 12105 sv = &types.StorageLensDataExport{} 12106 } else { 12107 sv = *v 12108 } 12109 12110 for { 12111 t, done, err := decoder.Token() 12112 if err != nil { 12113 return err 12114 } 12115 if done { 12116 break 12117 } 12118 originalDecoder := decoder 12119 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12120 switch { 12121 case strings.EqualFold("S3BucketDestination", t.Name.Local): 12122 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12123 if err := awsRestxml_deserializeDocumentS3BucketDestination(&sv.S3BucketDestination, nodeDecoder); err != nil { 12124 return err 12125 } 12126 12127 default: 12128 // Do nothing and ignore the unexpected tag element 12129 err = decoder.Decoder.Skip() 12130 if err != nil { 12131 return err 12132 } 12133 12134 } 12135 decoder = originalDecoder 12136 } 12137 *v = sv 12138 return nil 12139} 12140 12141func awsRestxml_deserializeDocumentStorageLensDataExportEncryption(v **types.StorageLensDataExportEncryption, decoder smithyxml.NodeDecoder) error { 12142 if v == nil { 12143 return fmt.Errorf("unexpected nil of type %T", v) 12144 } 12145 var sv *types.StorageLensDataExportEncryption 12146 if *v == nil { 12147 sv = &types.StorageLensDataExportEncryption{} 12148 } else { 12149 sv = *v 12150 } 12151 12152 for { 12153 t, done, err := decoder.Token() 12154 if err != nil { 12155 return err 12156 } 12157 if done { 12158 break 12159 } 12160 originalDecoder := decoder 12161 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12162 switch { 12163 case strings.EqualFold("SSE-KMS", t.Name.Local): 12164 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12165 if err := awsRestxml_deserializeDocumentSSEKMS(&sv.SSEKMS, nodeDecoder); err != nil { 12166 return err 12167 } 12168 12169 case strings.EqualFold("SSE-S3", t.Name.Local): 12170 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12171 if err := awsRestxml_deserializeDocumentSSES3(&sv.SSES3, nodeDecoder); err != nil { 12172 return err 12173 } 12174 12175 default: 12176 // Do nothing and ignore the unexpected tag element 12177 err = decoder.Decoder.Skip() 12178 if err != nil { 12179 return err 12180 } 12181 12182 } 12183 decoder = originalDecoder 12184 } 12185 *v = sv 12186 return nil 12187} 12188 12189func awsRestxml_deserializeDocumentStorageLensTag(v **types.StorageLensTag, decoder smithyxml.NodeDecoder) error { 12190 if v == nil { 12191 return fmt.Errorf("unexpected nil of type %T", v) 12192 } 12193 var sv *types.StorageLensTag 12194 if *v == nil { 12195 sv = &types.StorageLensTag{} 12196 } else { 12197 sv = *v 12198 } 12199 12200 for { 12201 t, done, err := decoder.Token() 12202 if err != nil { 12203 return err 12204 } 12205 if done { 12206 break 12207 } 12208 originalDecoder := decoder 12209 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12210 switch { 12211 case strings.EqualFold("Key", t.Name.Local): 12212 val, err := decoder.Value() 12213 if err != nil { 12214 return err 12215 } 12216 if val == nil { 12217 break 12218 } 12219 { 12220 xtv := string(val) 12221 sv.Key = ptr.String(xtv) 12222 } 12223 12224 case strings.EqualFold("Value", t.Name.Local): 12225 val, err := decoder.Value() 12226 if err != nil { 12227 return err 12228 } 12229 if val == nil { 12230 break 12231 } 12232 { 12233 xtv := string(val) 12234 sv.Value = ptr.String(xtv) 12235 } 12236 12237 default: 12238 // Do nothing and ignore the unexpected tag element 12239 err = decoder.Decoder.Skip() 12240 if err != nil { 12241 return err 12242 } 12243 12244 } 12245 decoder = originalDecoder 12246 } 12247 *v = sv 12248 return nil 12249} 12250 12251func awsRestxml_deserializeDocumentStorageLensTags(v *[]types.StorageLensTag, decoder smithyxml.NodeDecoder) error { 12252 if v == nil { 12253 return fmt.Errorf("unexpected nil of type %T", v) 12254 } 12255 var sv []types.StorageLensTag 12256 if *v == nil { 12257 sv = make([]types.StorageLensTag, 0) 12258 } else { 12259 sv = *v 12260 } 12261 12262 originalDecoder := decoder 12263 for { 12264 t, done, err := decoder.Token() 12265 if err != nil { 12266 return err 12267 } 12268 if done { 12269 break 12270 } 12271 switch { 12272 case strings.EqualFold("Tag", t.Name.Local): 12273 var col types.StorageLensTag 12274 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12275 destAddr := &col 12276 if err := awsRestxml_deserializeDocumentStorageLensTag(&destAddr, nodeDecoder); err != nil { 12277 return err 12278 } 12279 col = *destAddr 12280 sv = append(sv, col) 12281 12282 default: 12283 err = decoder.Decoder.Skip() 12284 if err != nil { 12285 return err 12286 } 12287 12288 } 12289 decoder = originalDecoder 12290 } 12291 *v = sv 12292 return nil 12293} 12294 12295func awsRestxml_deserializeDocumentStorageLensTagsUnwrapped(v *[]types.StorageLensTag, decoder smithyxml.NodeDecoder) error { 12296 var sv []types.StorageLensTag 12297 if *v == nil { 12298 sv = make([]types.StorageLensTag, 0) 12299 } else { 12300 sv = *v 12301 } 12302 12303 switch { 12304 default: 12305 var mv types.StorageLensTag 12306 t := decoder.StartEl 12307 _ = t 12308 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12309 destAddr := &mv 12310 if err := awsRestxml_deserializeDocumentStorageLensTag(&destAddr, nodeDecoder); err != nil { 12311 return err 12312 } 12313 mv = *destAddr 12314 sv = append(sv, mv) 12315 } 12316 *v = sv 12317 return nil 12318} 12319func awsRestxml_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, decoder smithyxml.NodeDecoder) error { 12320 if v == nil { 12321 return fmt.Errorf("unexpected nil of type %T", v) 12322 } 12323 var sv *types.TooManyRequestsException 12324 if *v == nil { 12325 sv = &types.TooManyRequestsException{} 12326 } else { 12327 sv = *v 12328 } 12329 12330 for { 12331 t, done, err := decoder.Token() 12332 if err != nil { 12333 return err 12334 } 12335 if done { 12336 break 12337 } 12338 originalDecoder := decoder 12339 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12340 switch { 12341 case strings.EqualFold("Message", t.Name.Local): 12342 val, err := decoder.Value() 12343 if err != nil { 12344 return err 12345 } 12346 if val == nil { 12347 break 12348 } 12349 { 12350 xtv := string(val) 12351 sv.Message = ptr.String(xtv) 12352 } 12353 12354 default: 12355 // Do nothing and ignore the unexpected tag element 12356 err = decoder.Decoder.Skip() 12357 if err != nil { 12358 return err 12359 } 12360 12361 } 12362 decoder = originalDecoder 12363 } 12364 *v = sv 12365 return nil 12366} 12367 12368func awsRestxml_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, decoder smithyxml.NodeDecoder) error { 12369 if v == nil { 12370 return fmt.Errorf("unexpected nil of type %T", v) 12371 } 12372 var sv *types.TooManyTagsException 12373 if *v == nil { 12374 sv = &types.TooManyTagsException{} 12375 } else { 12376 sv = *v 12377 } 12378 12379 for { 12380 t, done, err := decoder.Token() 12381 if err != nil { 12382 return err 12383 } 12384 if done { 12385 break 12386 } 12387 originalDecoder := decoder 12388 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12389 switch { 12390 case strings.EqualFold("Message", t.Name.Local): 12391 val, err := decoder.Value() 12392 if err != nil { 12393 return err 12394 } 12395 if val == nil { 12396 break 12397 } 12398 { 12399 xtv := string(val) 12400 sv.Message = ptr.String(xtv) 12401 } 12402 12403 default: 12404 // Do nothing and ignore the unexpected tag element 12405 err = decoder.Decoder.Skip() 12406 if err != nil { 12407 return err 12408 } 12409 12410 } 12411 decoder = originalDecoder 12412 } 12413 *v = sv 12414 return nil 12415} 12416 12417func awsRestxml_deserializeDocumentTransition(v **types.Transition, decoder smithyxml.NodeDecoder) error { 12418 if v == nil { 12419 return fmt.Errorf("unexpected nil of type %T", v) 12420 } 12421 var sv *types.Transition 12422 if *v == nil { 12423 sv = &types.Transition{} 12424 } else { 12425 sv = *v 12426 } 12427 12428 for { 12429 t, done, err := decoder.Token() 12430 if err != nil { 12431 return err 12432 } 12433 if done { 12434 break 12435 } 12436 originalDecoder := decoder 12437 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12438 switch { 12439 case strings.EqualFold("Date", t.Name.Local): 12440 val, err := decoder.Value() 12441 if err != nil { 12442 return err 12443 } 12444 if val == nil { 12445 break 12446 } 12447 { 12448 xtv := string(val) 12449 t, err := smithytime.ParseDateTime(xtv) 12450 if err != nil { 12451 return err 12452 } 12453 sv.Date = ptr.Time(t) 12454 } 12455 12456 case strings.EqualFold("Days", t.Name.Local): 12457 val, err := decoder.Value() 12458 if err != nil { 12459 return err 12460 } 12461 if val == nil { 12462 break 12463 } 12464 { 12465 xtv := string(val) 12466 i64, err := strconv.ParseInt(xtv, 10, 64) 12467 if err != nil { 12468 return err 12469 } 12470 sv.Days = int32(i64) 12471 } 12472 12473 case strings.EqualFold("StorageClass", t.Name.Local): 12474 val, err := decoder.Value() 12475 if err != nil { 12476 return err 12477 } 12478 if val == nil { 12479 break 12480 } 12481 { 12482 xtv := string(val) 12483 sv.StorageClass = types.TransitionStorageClass(xtv) 12484 } 12485 12486 default: 12487 // Do nothing and ignore the unexpected tag element 12488 err = decoder.Decoder.Skip() 12489 if err != nil { 12490 return err 12491 } 12492 12493 } 12494 decoder = originalDecoder 12495 } 12496 *v = sv 12497 return nil 12498} 12499 12500func awsRestxml_deserializeDocumentTransitionList(v *[]types.Transition, decoder smithyxml.NodeDecoder) error { 12501 if v == nil { 12502 return fmt.Errorf("unexpected nil of type %T", v) 12503 } 12504 var sv []types.Transition 12505 if *v == nil { 12506 sv = make([]types.Transition, 0) 12507 } else { 12508 sv = *v 12509 } 12510 12511 originalDecoder := decoder 12512 for { 12513 t, done, err := decoder.Token() 12514 if err != nil { 12515 return err 12516 } 12517 if done { 12518 break 12519 } 12520 switch { 12521 case strings.EqualFold("Transition", t.Name.Local): 12522 var col types.Transition 12523 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12524 destAddr := &col 12525 if err := awsRestxml_deserializeDocumentTransition(&destAddr, nodeDecoder); err != nil { 12526 return err 12527 } 12528 col = *destAddr 12529 sv = append(sv, col) 12530 12531 default: 12532 err = decoder.Decoder.Skip() 12533 if err != nil { 12534 return err 12535 } 12536 12537 } 12538 decoder = originalDecoder 12539 } 12540 *v = sv 12541 return nil 12542} 12543 12544func awsRestxml_deserializeDocumentTransitionListUnwrapped(v *[]types.Transition, decoder smithyxml.NodeDecoder) error { 12545 var sv []types.Transition 12546 if *v == nil { 12547 sv = make([]types.Transition, 0) 12548 } else { 12549 sv = *v 12550 } 12551 12552 switch { 12553 default: 12554 var mv types.Transition 12555 t := decoder.StartEl 12556 _ = t 12557 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12558 destAddr := &mv 12559 if err := awsRestxml_deserializeDocumentTransition(&destAddr, nodeDecoder); err != nil { 12560 return err 12561 } 12562 mv = *destAddr 12563 sv = append(sv, mv) 12564 } 12565 *v = sv 12566 return nil 12567} 12568func awsRestxml_deserializeDocumentVpcConfiguration(v **types.VpcConfiguration, decoder smithyxml.NodeDecoder) error { 12569 if v == nil { 12570 return fmt.Errorf("unexpected nil of type %T", v) 12571 } 12572 var sv *types.VpcConfiguration 12573 if *v == nil { 12574 sv = &types.VpcConfiguration{} 12575 } else { 12576 sv = *v 12577 } 12578 12579 for { 12580 t, done, err := decoder.Token() 12581 if err != nil { 12582 return err 12583 } 12584 if done { 12585 break 12586 } 12587 originalDecoder := decoder 12588 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12589 switch { 12590 case strings.EqualFold("VpcId", t.Name.Local): 12591 val, err := decoder.Value() 12592 if err != nil { 12593 return err 12594 } 12595 if val == nil { 12596 break 12597 } 12598 { 12599 xtv := string(val) 12600 sv.VpcId = ptr.String(xtv) 12601 } 12602 12603 default: 12604 // Do nothing and ignore the unexpected tag element 12605 err = decoder.Decoder.Skip() 12606 if err != nil { 12607 return err 12608 } 12609 12610 } 12611 decoder = originalDecoder 12612 } 12613 *v = sv 12614 return nil 12615} 12616