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