1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package route53 4 5import ( 6 "bytes" 7 "context" 8 "encoding/xml" 9 "fmt" 10 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 11 awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml" 12 "github.com/aws/aws-sdk-go-v2/service/route53/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 "strconv" 22 "strings" 23) 24 25type awsRestxml_deserializeOpActivateKeySigningKey struct { 26} 27 28func (*awsRestxml_deserializeOpActivateKeySigningKey) ID() string { 29 return "OperationDeserializer" 30} 31 32func (m *awsRestxml_deserializeOpActivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 33 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 34) { 35 out, metadata, err = next.HandleDeserialize(ctx, in) 36 if err != nil { 37 return out, metadata, err 38 } 39 40 response, ok := out.RawResponse.(*smithyhttp.Response) 41 if !ok { 42 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 43 } 44 45 if response.StatusCode < 200 || response.StatusCode >= 300 { 46 return out, metadata, awsRestxml_deserializeOpErrorActivateKeySigningKey(response, &metadata) 47 } 48 output := &ActivateKeySigningKeyOutput{} 49 out.Result = output 50 51 var buff [1024]byte 52 ringBuffer := smithyio.NewRingBuffer(buff[:]) 53 body := io.TeeReader(response.Body, ringBuffer) 54 rootDecoder := xml.NewDecoder(body) 55 t, err := smithyxml.FetchRootElement(rootDecoder) 56 if err == io.EOF { 57 return out, metadata, nil 58 } 59 if err != nil { 60 var snapshot bytes.Buffer 61 io.Copy(&snapshot, ringBuffer) 62 return out, metadata, &smithy.DeserializationError{ 63 Err: fmt.Errorf("failed to decode response body, %w", err), 64 Snapshot: snapshot.Bytes(), 65 } 66 } 67 68 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 69 err = awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(&output, decoder) 70 if err != nil { 71 var snapshot bytes.Buffer 72 io.Copy(&snapshot, ringBuffer) 73 return out, metadata, &smithy.DeserializationError{ 74 Err: fmt.Errorf("failed to decode response body, %w", err), 75 Snapshot: snapshot.Bytes(), 76 } 77 } 78 79 return out, metadata, err 80} 81 82func awsRestxml_deserializeOpErrorActivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 83 var errorBuffer bytes.Buffer 84 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 85 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 86 } 87 errorBody := bytes.NewReader(errorBuffer.Bytes()) 88 89 errorCode := "UnknownError" 90 errorMessage := errorCode 91 92 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 93 if err != nil { 94 return err 95 } 96 if reqID := errorComponents.RequestID; len(reqID) != 0 { 97 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 98 } 99 if len(errorComponents.Code) != 0 { 100 errorCode = errorComponents.Code 101 } 102 if len(errorComponents.Message) != 0 { 103 errorMessage = errorComponents.Message 104 } 105 errorBody.Seek(0, io.SeekStart) 106 switch { 107 case strings.EqualFold("ConcurrentModification", errorCode): 108 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 109 110 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 111 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 112 113 case strings.EqualFold("InvalidKMSArn", errorCode): 114 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 115 116 case strings.EqualFold("InvalidSigningStatus", errorCode): 117 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 118 119 case strings.EqualFold("NoSuchKeySigningKey", errorCode): 120 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody) 121 122 default: 123 genericError := &smithy.GenericAPIError{ 124 Code: errorCode, 125 Message: errorMessage, 126 } 127 return genericError 128 129 } 130} 131 132func awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(v **ActivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 133 if v == nil { 134 return fmt.Errorf("unexpected nil of type %T", v) 135 } 136 var sv *ActivateKeySigningKeyOutput 137 if *v == nil { 138 sv = &ActivateKeySigningKeyOutput{} 139 } else { 140 sv = *v 141 } 142 143 for { 144 t, done, err := decoder.Token() 145 if err != nil { 146 return err 147 } 148 if done { 149 break 150 } 151 originalDecoder := decoder 152 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 153 switch { 154 case strings.EqualFold("ChangeInfo", t.Name.Local): 155 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 156 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 157 return err 158 } 159 160 default: 161 // Do nothing and ignore the unexpected tag element 162 err = decoder.Decoder.Skip() 163 if err != nil { 164 return err 165 } 166 167 } 168 decoder = originalDecoder 169 } 170 *v = sv 171 return nil 172} 173 174type awsRestxml_deserializeOpAssociateVPCWithHostedZone struct { 175} 176 177func (*awsRestxml_deserializeOpAssociateVPCWithHostedZone) ID() string { 178 return "OperationDeserializer" 179} 180 181func (m *awsRestxml_deserializeOpAssociateVPCWithHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 182 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 183) { 184 out, metadata, err = next.HandleDeserialize(ctx, in) 185 if err != nil { 186 return out, metadata, err 187 } 188 189 response, ok := out.RawResponse.(*smithyhttp.Response) 190 if !ok { 191 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 192 } 193 194 if response.StatusCode < 200 || response.StatusCode >= 300 { 195 return out, metadata, awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response, &metadata) 196 } 197 output := &AssociateVPCWithHostedZoneOutput{} 198 out.Result = output 199 200 var buff [1024]byte 201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 202 body := io.TeeReader(response.Body, ringBuffer) 203 rootDecoder := xml.NewDecoder(body) 204 t, err := smithyxml.FetchRootElement(rootDecoder) 205 if err == io.EOF { 206 return out, metadata, nil 207 } 208 if err != nil { 209 var snapshot bytes.Buffer 210 io.Copy(&snapshot, ringBuffer) 211 return out, metadata, &smithy.DeserializationError{ 212 Err: fmt.Errorf("failed to decode response body, %w", err), 213 Snapshot: snapshot.Bytes(), 214 } 215 } 216 217 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 218 err = awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(&output, decoder) 219 if err != nil { 220 var snapshot bytes.Buffer 221 io.Copy(&snapshot, ringBuffer) 222 return out, metadata, &smithy.DeserializationError{ 223 Err: fmt.Errorf("failed to decode response body, %w", err), 224 Snapshot: snapshot.Bytes(), 225 } 226 } 227 228 return out, metadata, err 229} 230 231func awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 232 var errorBuffer bytes.Buffer 233 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 234 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 235 } 236 errorBody := bytes.NewReader(errorBuffer.Bytes()) 237 238 errorCode := "UnknownError" 239 errorMessage := errorCode 240 241 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 242 if err != nil { 243 return err 244 } 245 if reqID := errorComponents.RequestID; len(reqID) != 0 { 246 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 247 } 248 if len(errorComponents.Code) != 0 { 249 errorCode = errorComponents.Code 250 } 251 if len(errorComponents.Message) != 0 { 252 errorMessage = errorComponents.Message 253 } 254 errorBody.Seek(0, io.SeekStart) 255 switch { 256 case strings.EqualFold("ConflictingDomainExists", errorCode): 257 return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody) 258 259 case strings.EqualFold("InvalidInput", errorCode): 260 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 261 262 case strings.EqualFold("InvalidVPCId", errorCode): 263 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 264 265 case strings.EqualFold("LimitsExceeded", errorCode): 266 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody) 267 268 case strings.EqualFold("NoSuchHostedZone", errorCode): 269 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 270 271 case strings.EqualFold("NotAuthorizedException", errorCode): 272 return awsRestxml_deserializeErrorNotAuthorizedException(response, errorBody) 273 274 case strings.EqualFold("PriorRequestNotComplete", errorCode): 275 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 276 277 case strings.EqualFold("PublicZoneVPCAssociation", errorCode): 278 return awsRestxml_deserializeErrorPublicZoneVPCAssociation(response, errorBody) 279 280 default: 281 genericError := &smithy.GenericAPIError{ 282 Code: errorCode, 283 Message: errorMessage, 284 } 285 return genericError 286 287 } 288} 289 290func awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(v **AssociateVPCWithHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 291 if v == nil { 292 return fmt.Errorf("unexpected nil of type %T", v) 293 } 294 var sv *AssociateVPCWithHostedZoneOutput 295 if *v == nil { 296 sv = &AssociateVPCWithHostedZoneOutput{} 297 } else { 298 sv = *v 299 } 300 301 for { 302 t, done, err := decoder.Token() 303 if err != nil { 304 return err 305 } 306 if done { 307 break 308 } 309 originalDecoder := decoder 310 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 311 switch { 312 case strings.EqualFold("ChangeInfo", t.Name.Local): 313 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 314 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 315 return err 316 } 317 318 default: 319 // Do nothing and ignore the unexpected tag element 320 err = decoder.Decoder.Skip() 321 if err != nil { 322 return err 323 } 324 325 } 326 decoder = originalDecoder 327 } 328 *v = sv 329 return nil 330} 331 332type awsRestxml_deserializeOpChangeResourceRecordSets struct { 333} 334 335func (*awsRestxml_deserializeOpChangeResourceRecordSets) ID() string { 336 return "OperationDeserializer" 337} 338 339func (m *awsRestxml_deserializeOpChangeResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 340 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 341) { 342 out, metadata, err = next.HandleDeserialize(ctx, in) 343 if err != nil { 344 return out, metadata, err 345 } 346 347 response, ok := out.RawResponse.(*smithyhttp.Response) 348 if !ok { 349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 350 } 351 352 if response.StatusCode < 200 || response.StatusCode >= 300 { 353 return out, metadata, awsRestxml_deserializeOpErrorChangeResourceRecordSets(response, &metadata) 354 } 355 output := &ChangeResourceRecordSetsOutput{} 356 out.Result = output 357 358 var buff [1024]byte 359 ringBuffer := smithyio.NewRingBuffer(buff[:]) 360 body := io.TeeReader(response.Body, ringBuffer) 361 rootDecoder := xml.NewDecoder(body) 362 t, err := smithyxml.FetchRootElement(rootDecoder) 363 if err == io.EOF { 364 return out, metadata, nil 365 } 366 if err != nil { 367 var snapshot bytes.Buffer 368 io.Copy(&snapshot, ringBuffer) 369 return out, metadata, &smithy.DeserializationError{ 370 Err: fmt.Errorf("failed to decode response body, %w", err), 371 Snapshot: snapshot.Bytes(), 372 } 373 } 374 375 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 376 err = awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(&output, decoder) 377 if err != nil { 378 var snapshot bytes.Buffer 379 io.Copy(&snapshot, ringBuffer) 380 return out, metadata, &smithy.DeserializationError{ 381 Err: fmt.Errorf("failed to decode response body, %w", err), 382 Snapshot: snapshot.Bytes(), 383 } 384 } 385 386 return out, metadata, err 387} 388 389func awsRestxml_deserializeOpErrorChangeResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 390 var errorBuffer bytes.Buffer 391 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 392 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 393 } 394 errorBody := bytes.NewReader(errorBuffer.Bytes()) 395 396 errorCode := "UnknownError" 397 errorMessage := errorCode 398 399 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 400 if err != nil { 401 return err 402 } 403 if reqID := errorComponents.RequestID; len(reqID) != 0 { 404 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 405 } 406 if len(errorComponents.Code) != 0 { 407 errorCode = errorComponents.Code 408 } 409 if len(errorComponents.Message) != 0 { 410 errorMessage = errorComponents.Message 411 } 412 errorBody.Seek(0, io.SeekStart) 413 switch { 414 case strings.EqualFold("InvalidChangeBatch", errorCode): 415 return awsRestxml_deserializeErrorInvalidChangeBatch(response, errorBody) 416 417 case strings.EqualFold("InvalidInput", errorCode): 418 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 419 420 case strings.EqualFold("NoSuchHealthCheck", errorCode): 421 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 422 423 case strings.EqualFold("NoSuchHostedZone", errorCode): 424 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 425 426 case strings.EqualFold("PriorRequestNotComplete", errorCode): 427 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 428 429 default: 430 genericError := &smithy.GenericAPIError{ 431 Code: errorCode, 432 Message: errorMessage, 433 } 434 return genericError 435 436 } 437} 438 439func awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(v **ChangeResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error { 440 if v == nil { 441 return fmt.Errorf("unexpected nil of type %T", v) 442 } 443 var sv *ChangeResourceRecordSetsOutput 444 if *v == nil { 445 sv = &ChangeResourceRecordSetsOutput{} 446 } else { 447 sv = *v 448 } 449 450 for { 451 t, done, err := decoder.Token() 452 if err != nil { 453 return err 454 } 455 if done { 456 break 457 } 458 originalDecoder := decoder 459 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 460 switch { 461 case strings.EqualFold("ChangeInfo", t.Name.Local): 462 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 463 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 464 return err 465 } 466 467 default: 468 // Do nothing and ignore the unexpected tag element 469 err = decoder.Decoder.Skip() 470 if err != nil { 471 return err 472 } 473 474 } 475 decoder = originalDecoder 476 } 477 *v = sv 478 return nil 479} 480 481type awsRestxml_deserializeOpChangeTagsForResource struct { 482} 483 484func (*awsRestxml_deserializeOpChangeTagsForResource) ID() string { 485 return "OperationDeserializer" 486} 487 488func (m *awsRestxml_deserializeOpChangeTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 489 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 490) { 491 out, metadata, err = next.HandleDeserialize(ctx, in) 492 if err != nil { 493 return out, metadata, err 494 } 495 496 response, ok := out.RawResponse.(*smithyhttp.Response) 497 if !ok { 498 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 499 } 500 501 if response.StatusCode < 200 || response.StatusCode >= 300 { 502 return out, metadata, awsRestxml_deserializeOpErrorChangeTagsForResource(response, &metadata) 503 } 504 output := &ChangeTagsForResourceOutput{} 505 out.Result = output 506 507 return out, metadata, err 508} 509 510func awsRestxml_deserializeOpErrorChangeTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 511 var errorBuffer bytes.Buffer 512 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 513 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 514 } 515 errorBody := bytes.NewReader(errorBuffer.Bytes()) 516 517 errorCode := "UnknownError" 518 errorMessage := errorCode 519 520 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 521 if err != nil { 522 return err 523 } 524 if reqID := errorComponents.RequestID; len(reqID) != 0 { 525 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 526 } 527 if len(errorComponents.Code) != 0 { 528 errorCode = errorComponents.Code 529 } 530 if len(errorComponents.Message) != 0 { 531 errorMessage = errorComponents.Message 532 } 533 errorBody.Seek(0, io.SeekStart) 534 switch { 535 case strings.EqualFold("InvalidInput", errorCode): 536 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 537 538 case strings.EqualFold("NoSuchHealthCheck", errorCode): 539 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 540 541 case strings.EqualFold("NoSuchHostedZone", errorCode): 542 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 543 544 case strings.EqualFold("PriorRequestNotComplete", errorCode): 545 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 546 547 case strings.EqualFold("ThrottlingException", errorCode): 548 return awsRestxml_deserializeErrorThrottlingException(response, errorBody) 549 550 default: 551 genericError := &smithy.GenericAPIError{ 552 Code: errorCode, 553 Message: errorMessage, 554 } 555 return genericError 556 557 } 558} 559 560type awsRestxml_deserializeOpCreateHealthCheck struct { 561} 562 563func (*awsRestxml_deserializeOpCreateHealthCheck) ID() string { 564 return "OperationDeserializer" 565} 566 567func (m *awsRestxml_deserializeOpCreateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 568 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 569) { 570 out, metadata, err = next.HandleDeserialize(ctx, in) 571 if err != nil { 572 return out, metadata, err 573 } 574 575 response, ok := out.RawResponse.(*smithyhttp.Response) 576 if !ok { 577 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 578 } 579 580 if response.StatusCode < 200 || response.StatusCode >= 300 { 581 return out, metadata, awsRestxml_deserializeOpErrorCreateHealthCheck(response, &metadata) 582 } 583 output := &CreateHealthCheckOutput{} 584 out.Result = output 585 586 err = awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(output, response) 587 if err != nil { 588 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 589 } 590 591 var buff [1024]byte 592 ringBuffer := smithyio.NewRingBuffer(buff[:]) 593 body := io.TeeReader(response.Body, ringBuffer) 594 rootDecoder := xml.NewDecoder(body) 595 t, err := smithyxml.FetchRootElement(rootDecoder) 596 if err == io.EOF { 597 return out, metadata, nil 598 } 599 if err != nil { 600 var snapshot bytes.Buffer 601 io.Copy(&snapshot, ringBuffer) 602 return out, metadata, &smithy.DeserializationError{ 603 Err: fmt.Errorf("failed to decode response body, %w", err), 604 Snapshot: snapshot.Bytes(), 605 } 606 } 607 608 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 609 err = awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(&output, decoder) 610 if err != nil { 611 var snapshot bytes.Buffer 612 io.Copy(&snapshot, ringBuffer) 613 return out, metadata, &smithy.DeserializationError{ 614 Err: fmt.Errorf("failed to decode response body, %w", err), 615 Snapshot: snapshot.Bytes(), 616 } 617 } 618 619 return out, metadata, err 620} 621 622func awsRestxml_deserializeOpErrorCreateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 623 var errorBuffer bytes.Buffer 624 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 625 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 626 } 627 errorBody := bytes.NewReader(errorBuffer.Bytes()) 628 629 errorCode := "UnknownError" 630 errorMessage := errorCode 631 632 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 633 if err != nil { 634 return err 635 } 636 if reqID := errorComponents.RequestID; len(reqID) != 0 { 637 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 638 } 639 if len(errorComponents.Code) != 0 { 640 errorCode = errorComponents.Code 641 } 642 if len(errorComponents.Message) != 0 { 643 errorMessage = errorComponents.Message 644 } 645 errorBody.Seek(0, io.SeekStart) 646 switch { 647 case strings.EqualFold("HealthCheckAlreadyExists", errorCode): 648 return awsRestxml_deserializeErrorHealthCheckAlreadyExists(response, errorBody) 649 650 case strings.EqualFold("InvalidInput", errorCode): 651 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 652 653 case strings.EqualFold("TooManyHealthChecks", errorCode): 654 return awsRestxml_deserializeErrorTooManyHealthChecks(response, errorBody) 655 656 default: 657 genericError := &smithy.GenericAPIError{ 658 Code: errorCode, 659 Message: errorMessage, 660 } 661 return genericError 662 663 } 664} 665 666func awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(v *CreateHealthCheckOutput, response *smithyhttp.Response) error { 667 if v == nil { 668 return fmt.Errorf("unsupported deserialization for nil %T", v) 669 } 670 671 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 672 headerValues[0] = strings.TrimSpace(headerValues[0]) 673 v.Location = ptr.String(headerValues[0]) 674 } 675 676 return nil 677} 678func awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(v **CreateHealthCheckOutput, decoder smithyxml.NodeDecoder) error { 679 if v == nil { 680 return fmt.Errorf("unexpected nil of type %T", v) 681 } 682 var sv *CreateHealthCheckOutput 683 if *v == nil { 684 sv = &CreateHealthCheckOutput{} 685 } else { 686 sv = *v 687 } 688 689 for { 690 t, done, err := decoder.Token() 691 if err != nil { 692 return err 693 } 694 if done { 695 break 696 } 697 originalDecoder := decoder 698 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 699 switch { 700 case strings.EqualFold("HealthCheck", t.Name.Local): 701 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 702 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil { 703 return err 704 } 705 706 default: 707 // Do nothing and ignore the unexpected tag element 708 err = decoder.Decoder.Skip() 709 if err != nil { 710 return err 711 } 712 713 } 714 decoder = originalDecoder 715 } 716 *v = sv 717 return nil 718} 719 720type awsRestxml_deserializeOpCreateHostedZone struct { 721} 722 723func (*awsRestxml_deserializeOpCreateHostedZone) ID() string { 724 return "OperationDeserializer" 725} 726 727func (m *awsRestxml_deserializeOpCreateHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 728 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 729) { 730 out, metadata, err = next.HandleDeserialize(ctx, in) 731 if err != nil { 732 return out, metadata, err 733 } 734 735 response, ok := out.RawResponse.(*smithyhttp.Response) 736 if !ok { 737 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 738 } 739 740 if response.StatusCode < 200 || response.StatusCode >= 300 { 741 return out, metadata, awsRestxml_deserializeOpErrorCreateHostedZone(response, &metadata) 742 } 743 output := &CreateHostedZoneOutput{} 744 out.Result = output 745 746 err = awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(output, response) 747 if err != nil { 748 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 749 } 750 751 var buff [1024]byte 752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 753 body := io.TeeReader(response.Body, ringBuffer) 754 rootDecoder := xml.NewDecoder(body) 755 t, err := smithyxml.FetchRootElement(rootDecoder) 756 if err == io.EOF { 757 return out, metadata, nil 758 } 759 if err != nil { 760 var snapshot bytes.Buffer 761 io.Copy(&snapshot, ringBuffer) 762 return out, metadata, &smithy.DeserializationError{ 763 Err: fmt.Errorf("failed to decode response body, %w", err), 764 Snapshot: snapshot.Bytes(), 765 } 766 } 767 768 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 769 err = awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(&output, decoder) 770 if err != nil { 771 var snapshot bytes.Buffer 772 io.Copy(&snapshot, ringBuffer) 773 return out, metadata, &smithy.DeserializationError{ 774 Err: fmt.Errorf("failed to decode response body, %w", err), 775 Snapshot: snapshot.Bytes(), 776 } 777 } 778 779 return out, metadata, err 780} 781 782func awsRestxml_deserializeOpErrorCreateHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 783 var errorBuffer bytes.Buffer 784 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 785 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 786 } 787 errorBody := bytes.NewReader(errorBuffer.Bytes()) 788 789 errorCode := "UnknownError" 790 errorMessage := errorCode 791 792 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 793 if err != nil { 794 return err 795 } 796 if reqID := errorComponents.RequestID; len(reqID) != 0 { 797 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 798 } 799 if len(errorComponents.Code) != 0 { 800 errorCode = errorComponents.Code 801 } 802 if len(errorComponents.Message) != 0 { 803 errorMessage = errorComponents.Message 804 } 805 errorBody.Seek(0, io.SeekStart) 806 switch { 807 case strings.EqualFold("ConflictingDomainExists", errorCode): 808 return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody) 809 810 case strings.EqualFold("DelegationSetNotAvailable", errorCode): 811 return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody) 812 813 case strings.EqualFold("DelegationSetNotReusable", errorCode): 814 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 815 816 case strings.EqualFold("HostedZoneAlreadyExists", errorCode): 817 return awsRestxml_deserializeErrorHostedZoneAlreadyExists(response, errorBody) 818 819 case strings.EqualFold("InvalidDomainName", errorCode): 820 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody) 821 822 case strings.EqualFold("InvalidInput", errorCode): 823 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 824 825 case strings.EqualFold("InvalidVPCId", errorCode): 826 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 827 828 case strings.EqualFold("NoSuchDelegationSet", errorCode): 829 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 830 831 case strings.EqualFold("TooManyHostedZones", errorCode): 832 return awsRestxml_deserializeErrorTooManyHostedZones(response, errorBody) 833 834 default: 835 genericError := &smithy.GenericAPIError{ 836 Code: errorCode, 837 Message: errorMessage, 838 } 839 return genericError 840 841 } 842} 843 844func awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(v *CreateHostedZoneOutput, response *smithyhttp.Response) error { 845 if v == nil { 846 return fmt.Errorf("unsupported deserialization for nil %T", v) 847 } 848 849 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 850 headerValues[0] = strings.TrimSpace(headerValues[0]) 851 v.Location = ptr.String(headerValues[0]) 852 } 853 854 return nil 855} 856func awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(v **CreateHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 857 if v == nil { 858 return fmt.Errorf("unexpected nil of type %T", v) 859 } 860 var sv *CreateHostedZoneOutput 861 if *v == nil { 862 sv = &CreateHostedZoneOutput{} 863 } else { 864 sv = *v 865 } 866 867 for { 868 t, done, err := decoder.Token() 869 if err != nil { 870 return err 871 } 872 if done { 873 break 874 } 875 originalDecoder := decoder 876 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 877 switch { 878 case strings.EqualFold("ChangeInfo", t.Name.Local): 879 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 880 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 881 return err 882 } 883 884 case strings.EqualFold("DelegationSet", t.Name.Local): 885 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 886 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 887 return err 888 } 889 890 case strings.EqualFold("HostedZone", t.Name.Local): 891 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 892 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil { 893 return err 894 } 895 896 case strings.EqualFold("VPC", t.Name.Local): 897 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 898 if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil { 899 return err 900 } 901 902 default: 903 // Do nothing and ignore the unexpected tag element 904 err = decoder.Decoder.Skip() 905 if err != nil { 906 return err 907 } 908 909 } 910 decoder = originalDecoder 911 } 912 *v = sv 913 return nil 914} 915 916type awsRestxml_deserializeOpCreateKeySigningKey struct { 917} 918 919func (*awsRestxml_deserializeOpCreateKeySigningKey) ID() string { 920 return "OperationDeserializer" 921} 922 923func (m *awsRestxml_deserializeOpCreateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 924 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 925) { 926 out, metadata, err = next.HandleDeserialize(ctx, in) 927 if err != nil { 928 return out, metadata, err 929 } 930 931 response, ok := out.RawResponse.(*smithyhttp.Response) 932 if !ok { 933 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 934 } 935 936 if response.StatusCode < 200 || response.StatusCode >= 300 { 937 return out, metadata, awsRestxml_deserializeOpErrorCreateKeySigningKey(response, &metadata) 938 } 939 output := &CreateKeySigningKeyOutput{} 940 out.Result = output 941 942 err = awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(output, response) 943 if err != nil { 944 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 945 } 946 947 var buff [1024]byte 948 ringBuffer := smithyio.NewRingBuffer(buff[:]) 949 body := io.TeeReader(response.Body, ringBuffer) 950 rootDecoder := xml.NewDecoder(body) 951 t, err := smithyxml.FetchRootElement(rootDecoder) 952 if err == io.EOF { 953 return out, metadata, nil 954 } 955 if err != nil { 956 var snapshot bytes.Buffer 957 io.Copy(&snapshot, ringBuffer) 958 return out, metadata, &smithy.DeserializationError{ 959 Err: fmt.Errorf("failed to decode response body, %w", err), 960 Snapshot: snapshot.Bytes(), 961 } 962 } 963 964 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 965 err = awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(&output, decoder) 966 if err != nil { 967 var snapshot bytes.Buffer 968 io.Copy(&snapshot, ringBuffer) 969 return out, metadata, &smithy.DeserializationError{ 970 Err: fmt.Errorf("failed to decode response body, %w", err), 971 Snapshot: snapshot.Bytes(), 972 } 973 } 974 975 return out, metadata, err 976} 977 978func awsRestxml_deserializeOpErrorCreateKeySigningKey(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 := awsxml.GetErrorResponseComponents(errorBody, false) 989 if err != nil { 990 return err 991 } 992 if reqID := errorComponents.RequestID; len(reqID) != 0 { 993 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 994 } 995 if len(errorComponents.Code) != 0 { 996 errorCode = errorComponents.Code 997 } 998 if len(errorComponents.Message) != 0 { 999 errorMessage = errorComponents.Message 1000 } 1001 errorBody.Seek(0, io.SeekStart) 1002 switch { 1003 case strings.EqualFold("ConcurrentModification", errorCode): 1004 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 1005 1006 case strings.EqualFold("InvalidArgument", errorCode): 1007 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 1008 1009 case strings.EqualFold("InvalidInput", errorCode): 1010 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1011 1012 case strings.EqualFold("InvalidKeySigningKeyName", errorCode): 1013 return awsRestxml_deserializeErrorInvalidKeySigningKeyName(response, errorBody) 1014 1015 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 1016 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 1017 1018 case strings.EqualFold("InvalidKMSArn", errorCode): 1019 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 1020 1021 case strings.EqualFold("InvalidSigningStatus", errorCode): 1022 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 1023 1024 case strings.EqualFold("KeySigningKeyAlreadyExists", errorCode): 1025 return awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response, errorBody) 1026 1027 case strings.EqualFold("NoSuchHostedZone", errorCode): 1028 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 1029 1030 case strings.EqualFold("TooManyKeySigningKeys", errorCode): 1031 return awsRestxml_deserializeErrorTooManyKeySigningKeys(response, errorBody) 1032 1033 default: 1034 genericError := &smithy.GenericAPIError{ 1035 Code: errorCode, 1036 Message: errorMessage, 1037 } 1038 return genericError 1039 1040 } 1041} 1042 1043func awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(v *CreateKeySigningKeyOutput, response *smithyhttp.Response) error { 1044 if v == nil { 1045 return fmt.Errorf("unsupported deserialization for nil %T", v) 1046 } 1047 1048 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1049 headerValues[0] = strings.TrimSpace(headerValues[0]) 1050 v.Location = ptr.String(headerValues[0]) 1051 } 1052 1053 return nil 1054} 1055func awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(v **CreateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 1056 if v == nil { 1057 return fmt.Errorf("unexpected nil of type %T", v) 1058 } 1059 var sv *CreateKeySigningKeyOutput 1060 if *v == nil { 1061 sv = &CreateKeySigningKeyOutput{} 1062 } else { 1063 sv = *v 1064 } 1065 1066 for { 1067 t, done, err := decoder.Token() 1068 if err != nil { 1069 return err 1070 } 1071 if done { 1072 break 1073 } 1074 originalDecoder := decoder 1075 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1076 switch { 1077 case strings.EqualFold("ChangeInfo", t.Name.Local): 1078 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1079 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 1080 return err 1081 } 1082 1083 case strings.EqualFold("KeySigningKey", t.Name.Local): 1084 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1085 if err := awsRestxml_deserializeDocumentKeySigningKey(&sv.KeySigningKey, nodeDecoder); err != nil { 1086 return err 1087 } 1088 1089 default: 1090 // Do nothing and ignore the unexpected tag element 1091 err = decoder.Decoder.Skip() 1092 if err != nil { 1093 return err 1094 } 1095 1096 } 1097 decoder = originalDecoder 1098 } 1099 *v = sv 1100 return nil 1101} 1102 1103type awsRestxml_deserializeOpCreateQueryLoggingConfig struct { 1104} 1105 1106func (*awsRestxml_deserializeOpCreateQueryLoggingConfig) ID() string { 1107 return "OperationDeserializer" 1108} 1109 1110func (m *awsRestxml_deserializeOpCreateQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1111 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1112) { 1113 out, metadata, err = next.HandleDeserialize(ctx, in) 1114 if err != nil { 1115 return out, metadata, err 1116 } 1117 1118 response, ok := out.RawResponse.(*smithyhttp.Response) 1119 if !ok { 1120 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1121 } 1122 1123 if response.StatusCode < 200 || response.StatusCode >= 300 { 1124 return out, metadata, awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response, &metadata) 1125 } 1126 output := &CreateQueryLoggingConfigOutput{} 1127 out.Result = output 1128 1129 err = awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(output, response) 1130 if err != nil { 1131 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1132 } 1133 1134 var buff [1024]byte 1135 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1136 body := io.TeeReader(response.Body, ringBuffer) 1137 rootDecoder := xml.NewDecoder(body) 1138 t, err := smithyxml.FetchRootElement(rootDecoder) 1139 if err == io.EOF { 1140 return out, metadata, nil 1141 } 1142 if err != nil { 1143 var snapshot bytes.Buffer 1144 io.Copy(&snapshot, ringBuffer) 1145 return out, metadata, &smithy.DeserializationError{ 1146 Err: fmt.Errorf("failed to decode response body, %w", err), 1147 Snapshot: snapshot.Bytes(), 1148 } 1149 } 1150 1151 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1152 err = awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(&output, decoder) 1153 if err != nil { 1154 var snapshot bytes.Buffer 1155 io.Copy(&snapshot, ringBuffer) 1156 return out, metadata, &smithy.DeserializationError{ 1157 Err: fmt.Errorf("failed to decode response body, %w", err), 1158 Snapshot: snapshot.Bytes(), 1159 } 1160 } 1161 1162 return out, metadata, err 1163} 1164 1165func awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1166 var errorBuffer bytes.Buffer 1167 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1168 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1169 } 1170 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1171 1172 errorCode := "UnknownError" 1173 errorMessage := errorCode 1174 1175 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1176 if err != nil { 1177 return err 1178 } 1179 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1180 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1181 } 1182 if len(errorComponents.Code) != 0 { 1183 errorCode = errorComponents.Code 1184 } 1185 if len(errorComponents.Message) != 0 { 1186 errorMessage = errorComponents.Message 1187 } 1188 errorBody.Seek(0, io.SeekStart) 1189 switch { 1190 case strings.EqualFold("ConcurrentModification", errorCode): 1191 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 1192 1193 case strings.EqualFold("InsufficientCloudWatchLogsResourcePolicy", errorCode): 1194 return awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response, errorBody) 1195 1196 case strings.EqualFold("InvalidInput", errorCode): 1197 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1198 1199 case strings.EqualFold("NoSuchCloudWatchLogsLogGroup", errorCode): 1200 return awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response, errorBody) 1201 1202 case strings.EqualFold("NoSuchHostedZone", errorCode): 1203 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 1204 1205 case strings.EqualFold("QueryLoggingConfigAlreadyExists", errorCode): 1206 return awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response, errorBody) 1207 1208 default: 1209 genericError := &smithy.GenericAPIError{ 1210 Code: errorCode, 1211 Message: errorMessage, 1212 } 1213 return genericError 1214 1215 } 1216} 1217 1218func awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(v *CreateQueryLoggingConfigOutput, response *smithyhttp.Response) error { 1219 if v == nil { 1220 return fmt.Errorf("unsupported deserialization for nil %T", v) 1221 } 1222 1223 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1224 headerValues[0] = strings.TrimSpace(headerValues[0]) 1225 v.Location = ptr.String(headerValues[0]) 1226 } 1227 1228 return nil 1229} 1230func awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(v **CreateQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error { 1231 if v == nil { 1232 return fmt.Errorf("unexpected nil of type %T", v) 1233 } 1234 var sv *CreateQueryLoggingConfigOutput 1235 if *v == nil { 1236 sv = &CreateQueryLoggingConfigOutput{} 1237 } else { 1238 sv = *v 1239 } 1240 1241 for { 1242 t, done, err := decoder.Token() 1243 if err != nil { 1244 return err 1245 } 1246 if done { 1247 break 1248 } 1249 originalDecoder := decoder 1250 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1251 switch { 1252 case strings.EqualFold("QueryLoggingConfig", t.Name.Local): 1253 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1254 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil { 1255 return err 1256 } 1257 1258 default: 1259 // Do nothing and ignore the unexpected tag element 1260 err = decoder.Decoder.Skip() 1261 if err != nil { 1262 return err 1263 } 1264 1265 } 1266 decoder = originalDecoder 1267 } 1268 *v = sv 1269 return nil 1270} 1271 1272type awsRestxml_deserializeOpCreateReusableDelegationSet struct { 1273} 1274 1275func (*awsRestxml_deserializeOpCreateReusableDelegationSet) ID() string { 1276 return "OperationDeserializer" 1277} 1278 1279func (m *awsRestxml_deserializeOpCreateReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1280 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1281) { 1282 out, metadata, err = next.HandleDeserialize(ctx, in) 1283 if err != nil { 1284 return out, metadata, err 1285 } 1286 1287 response, ok := out.RawResponse.(*smithyhttp.Response) 1288 if !ok { 1289 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1290 } 1291 1292 if response.StatusCode < 200 || response.StatusCode >= 300 { 1293 return out, metadata, awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response, &metadata) 1294 } 1295 output := &CreateReusableDelegationSetOutput{} 1296 out.Result = output 1297 1298 err = awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(output, response) 1299 if err != nil { 1300 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1301 } 1302 1303 var buff [1024]byte 1304 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1305 body := io.TeeReader(response.Body, ringBuffer) 1306 rootDecoder := xml.NewDecoder(body) 1307 t, err := smithyxml.FetchRootElement(rootDecoder) 1308 if err == io.EOF { 1309 return out, metadata, nil 1310 } 1311 if err != nil { 1312 var snapshot bytes.Buffer 1313 io.Copy(&snapshot, ringBuffer) 1314 return out, metadata, &smithy.DeserializationError{ 1315 Err: fmt.Errorf("failed to decode response body, %w", err), 1316 Snapshot: snapshot.Bytes(), 1317 } 1318 } 1319 1320 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1321 err = awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(&output, decoder) 1322 if err != nil { 1323 var snapshot bytes.Buffer 1324 io.Copy(&snapshot, ringBuffer) 1325 return out, metadata, &smithy.DeserializationError{ 1326 Err: fmt.Errorf("failed to decode response body, %w", err), 1327 Snapshot: snapshot.Bytes(), 1328 } 1329 } 1330 1331 return out, metadata, err 1332} 1333 1334func awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1335 var errorBuffer bytes.Buffer 1336 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1337 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1338 } 1339 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1340 1341 errorCode := "UnknownError" 1342 errorMessage := errorCode 1343 1344 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1345 if err != nil { 1346 return err 1347 } 1348 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1349 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1350 } 1351 if len(errorComponents.Code) != 0 { 1352 errorCode = errorComponents.Code 1353 } 1354 if len(errorComponents.Message) != 0 { 1355 errorMessage = errorComponents.Message 1356 } 1357 errorBody.Seek(0, io.SeekStart) 1358 switch { 1359 case strings.EqualFold("DelegationSetAlreadyCreated", errorCode): 1360 return awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response, errorBody) 1361 1362 case strings.EqualFold("DelegationSetAlreadyReusable", errorCode): 1363 return awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response, errorBody) 1364 1365 case strings.EqualFold("DelegationSetNotAvailable", errorCode): 1366 return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody) 1367 1368 case strings.EqualFold("HostedZoneNotFound", errorCode): 1369 return awsRestxml_deserializeErrorHostedZoneNotFound(response, errorBody) 1370 1371 case strings.EqualFold("InvalidArgument", errorCode): 1372 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 1373 1374 case strings.EqualFold("InvalidInput", errorCode): 1375 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1376 1377 case strings.EqualFold("LimitsExceeded", errorCode): 1378 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody) 1379 1380 default: 1381 genericError := &smithy.GenericAPIError{ 1382 Code: errorCode, 1383 Message: errorMessage, 1384 } 1385 return genericError 1386 1387 } 1388} 1389 1390func awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(v *CreateReusableDelegationSetOutput, response *smithyhttp.Response) error { 1391 if v == nil { 1392 return fmt.Errorf("unsupported deserialization for nil %T", v) 1393 } 1394 1395 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1396 headerValues[0] = strings.TrimSpace(headerValues[0]) 1397 v.Location = ptr.String(headerValues[0]) 1398 } 1399 1400 return nil 1401} 1402func awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(v **CreateReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error { 1403 if v == nil { 1404 return fmt.Errorf("unexpected nil of type %T", v) 1405 } 1406 var sv *CreateReusableDelegationSetOutput 1407 if *v == nil { 1408 sv = &CreateReusableDelegationSetOutput{} 1409 } else { 1410 sv = *v 1411 } 1412 1413 for { 1414 t, done, err := decoder.Token() 1415 if err != nil { 1416 return err 1417 } 1418 if done { 1419 break 1420 } 1421 originalDecoder := decoder 1422 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1423 switch { 1424 case strings.EqualFold("DelegationSet", t.Name.Local): 1425 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1426 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 1427 return err 1428 } 1429 1430 default: 1431 // Do nothing and ignore the unexpected tag element 1432 err = decoder.Decoder.Skip() 1433 if err != nil { 1434 return err 1435 } 1436 1437 } 1438 decoder = originalDecoder 1439 } 1440 *v = sv 1441 return nil 1442} 1443 1444type awsRestxml_deserializeOpCreateTrafficPolicy struct { 1445} 1446 1447func (*awsRestxml_deserializeOpCreateTrafficPolicy) ID() string { 1448 return "OperationDeserializer" 1449} 1450 1451func (m *awsRestxml_deserializeOpCreateTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1452 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1453) { 1454 out, metadata, err = next.HandleDeserialize(ctx, in) 1455 if err != nil { 1456 return out, metadata, err 1457 } 1458 1459 response, ok := out.RawResponse.(*smithyhttp.Response) 1460 if !ok { 1461 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1462 } 1463 1464 if response.StatusCode < 200 || response.StatusCode >= 300 { 1465 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicy(response, &metadata) 1466 } 1467 output := &CreateTrafficPolicyOutput{} 1468 out.Result = output 1469 1470 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(output, response) 1471 if err != nil { 1472 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1473 } 1474 1475 var buff [1024]byte 1476 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1477 body := io.TeeReader(response.Body, ringBuffer) 1478 rootDecoder := xml.NewDecoder(body) 1479 t, err := smithyxml.FetchRootElement(rootDecoder) 1480 if err == io.EOF { 1481 return out, metadata, nil 1482 } 1483 if err != nil { 1484 var snapshot bytes.Buffer 1485 io.Copy(&snapshot, ringBuffer) 1486 return out, metadata, &smithy.DeserializationError{ 1487 Err: fmt.Errorf("failed to decode response body, %w", err), 1488 Snapshot: snapshot.Bytes(), 1489 } 1490 } 1491 1492 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1493 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(&output, decoder) 1494 if err != nil { 1495 var snapshot bytes.Buffer 1496 io.Copy(&snapshot, ringBuffer) 1497 return out, metadata, &smithy.DeserializationError{ 1498 Err: fmt.Errorf("failed to decode response body, %w", err), 1499 Snapshot: snapshot.Bytes(), 1500 } 1501 } 1502 1503 return out, metadata, err 1504} 1505 1506func awsRestxml_deserializeOpErrorCreateTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1507 var errorBuffer bytes.Buffer 1508 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1509 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1510 } 1511 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1512 1513 errorCode := "UnknownError" 1514 errorMessage := errorCode 1515 1516 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1517 if err != nil { 1518 return err 1519 } 1520 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1521 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1522 } 1523 if len(errorComponents.Code) != 0 { 1524 errorCode = errorComponents.Code 1525 } 1526 if len(errorComponents.Message) != 0 { 1527 errorMessage = errorComponents.Message 1528 } 1529 errorBody.Seek(0, io.SeekStart) 1530 switch { 1531 case strings.EqualFold("InvalidInput", errorCode): 1532 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1533 1534 case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode): 1535 return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody) 1536 1537 case strings.EqualFold("TooManyTrafficPolicies", errorCode): 1538 return awsRestxml_deserializeErrorTooManyTrafficPolicies(response, errorBody) 1539 1540 case strings.EqualFold("TrafficPolicyAlreadyExists", errorCode): 1541 return awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response, errorBody) 1542 1543 default: 1544 genericError := &smithy.GenericAPIError{ 1545 Code: errorCode, 1546 Message: errorMessage, 1547 } 1548 return genericError 1549 1550 } 1551} 1552 1553func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(v *CreateTrafficPolicyOutput, response *smithyhttp.Response) error { 1554 if v == nil { 1555 return fmt.Errorf("unsupported deserialization for nil %T", v) 1556 } 1557 1558 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1559 headerValues[0] = strings.TrimSpace(headerValues[0]) 1560 v.Location = ptr.String(headerValues[0]) 1561 } 1562 1563 return nil 1564} 1565func awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(v **CreateTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error { 1566 if v == nil { 1567 return fmt.Errorf("unexpected nil of type %T", v) 1568 } 1569 var sv *CreateTrafficPolicyOutput 1570 if *v == nil { 1571 sv = &CreateTrafficPolicyOutput{} 1572 } else { 1573 sv = *v 1574 } 1575 1576 for { 1577 t, done, err := decoder.Token() 1578 if err != nil { 1579 return err 1580 } 1581 if done { 1582 break 1583 } 1584 originalDecoder := decoder 1585 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1586 switch { 1587 case strings.EqualFold("TrafficPolicy", t.Name.Local): 1588 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1589 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 1590 return err 1591 } 1592 1593 default: 1594 // Do nothing and ignore the unexpected tag element 1595 err = decoder.Decoder.Skip() 1596 if err != nil { 1597 return err 1598 } 1599 1600 } 1601 decoder = originalDecoder 1602 } 1603 *v = sv 1604 return nil 1605} 1606 1607type awsRestxml_deserializeOpCreateTrafficPolicyInstance struct { 1608} 1609 1610func (*awsRestxml_deserializeOpCreateTrafficPolicyInstance) ID() string { 1611 return "OperationDeserializer" 1612} 1613 1614func (m *awsRestxml_deserializeOpCreateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1615 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1616) { 1617 out, metadata, err = next.HandleDeserialize(ctx, in) 1618 if err != nil { 1619 return out, metadata, err 1620 } 1621 1622 response, ok := out.RawResponse.(*smithyhttp.Response) 1623 if !ok { 1624 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1625 } 1626 1627 if response.StatusCode < 200 || response.StatusCode >= 300 { 1628 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response, &metadata) 1629 } 1630 output := &CreateTrafficPolicyInstanceOutput{} 1631 out.Result = output 1632 1633 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(output, response) 1634 if err != nil { 1635 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1636 } 1637 1638 var buff [1024]byte 1639 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1640 body := io.TeeReader(response.Body, ringBuffer) 1641 rootDecoder := xml.NewDecoder(body) 1642 t, err := smithyxml.FetchRootElement(rootDecoder) 1643 if err == io.EOF { 1644 return out, metadata, nil 1645 } 1646 if err != nil { 1647 var snapshot bytes.Buffer 1648 io.Copy(&snapshot, ringBuffer) 1649 return out, metadata, &smithy.DeserializationError{ 1650 Err: fmt.Errorf("failed to decode response body, %w", err), 1651 Snapshot: snapshot.Bytes(), 1652 } 1653 } 1654 1655 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1656 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(&output, decoder) 1657 if err != nil { 1658 var snapshot bytes.Buffer 1659 io.Copy(&snapshot, ringBuffer) 1660 return out, metadata, &smithy.DeserializationError{ 1661 Err: fmt.Errorf("failed to decode response body, %w", err), 1662 Snapshot: snapshot.Bytes(), 1663 } 1664 } 1665 1666 return out, metadata, err 1667} 1668 1669func awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1670 var errorBuffer bytes.Buffer 1671 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1672 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1673 } 1674 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1675 1676 errorCode := "UnknownError" 1677 errorMessage := errorCode 1678 1679 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1680 if err != nil { 1681 return err 1682 } 1683 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1684 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1685 } 1686 if len(errorComponents.Code) != 0 { 1687 errorCode = errorComponents.Code 1688 } 1689 if len(errorComponents.Message) != 0 { 1690 errorMessage = errorComponents.Message 1691 } 1692 errorBody.Seek(0, io.SeekStart) 1693 switch { 1694 case strings.EqualFold("InvalidInput", errorCode): 1695 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1696 1697 case strings.EqualFold("NoSuchHostedZone", errorCode): 1698 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 1699 1700 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 1701 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 1702 1703 case strings.EqualFold("TooManyTrafficPolicyInstances", errorCode): 1704 return awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response, errorBody) 1705 1706 case strings.EqualFold("TrafficPolicyInstanceAlreadyExists", errorCode): 1707 return awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response, errorBody) 1708 1709 default: 1710 genericError := &smithy.GenericAPIError{ 1711 Code: errorCode, 1712 Message: errorMessage, 1713 } 1714 return genericError 1715 1716 } 1717} 1718 1719func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(v *CreateTrafficPolicyInstanceOutput, response *smithyhttp.Response) error { 1720 if v == nil { 1721 return fmt.Errorf("unsupported deserialization for nil %T", v) 1722 } 1723 1724 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1725 headerValues[0] = strings.TrimSpace(headerValues[0]) 1726 v.Location = ptr.String(headerValues[0]) 1727 } 1728 1729 return nil 1730} 1731func awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(v **CreateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error { 1732 if v == nil { 1733 return fmt.Errorf("unexpected nil of type %T", v) 1734 } 1735 var sv *CreateTrafficPolicyInstanceOutput 1736 if *v == nil { 1737 sv = &CreateTrafficPolicyInstanceOutput{} 1738 } else { 1739 sv = *v 1740 } 1741 1742 for { 1743 t, done, err := decoder.Token() 1744 if err != nil { 1745 return err 1746 } 1747 if done { 1748 break 1749 } 1750 originalDecoder := decoder 1751 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1752 switch { 1753 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 1754 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1755 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil { 1756 return err 1757 } 1758 1759 default: 1760 // Do nothing and ignore the unexpected tag element 1761 err = decoder.Decoder.Skip() 1762 if err != nil { 1763 return err 1764 } 1765 1766 } 1767 decoder = originalDecoder 1768 } 1769 *v = sv 1770 return nil 1771} 1772 1773type awsRestxml_deserializeOpCreateTrafficPolicyVersion struct { 1774} 1775 1776func (*awsRestxml_deserializeOpCreateTrafficPolicyVersion) ID() string { 1777 return "OperationDeserializer" 1778} 1779 1780func (m *awsRestxml_deserializeOpCreateTrafficPolicyVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1781 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1782) { 1783 out, metadata, err = next.HandleDeserialize(ctx, in) 1784 if err != nil { 1785 return out, metadata, err 1786 } 1787 1788 response, ok := out.RawResponse.(*smithyhttp.Response) 1789 if !ok { 1790 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1791 } 1792 1793 if response.StatusCode < 200 || response.StatusCode >= 300 { 1794 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response, &metadata) 1795 } 1796 output := &CreateTrafficPolicyVersionOutput{} 1797 out.Result = output 1798 1799 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(output, response) 1800 if err != nil { 1801 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1802 } 1803 1804 var buff [1024]byte 1805 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1806 body := io.TeeReader(response.Body, ringBuffer) 1807 rootDecoder := xml.NewDecoder(body) 1808 t, err := smithyxml.FetchRootElement(rootDecoder) 1809 if err == io.EOF { 1810 return out, metadata, nil 1811 } 1812 if err != nil { 1813 var snapshot bytes.Buffer 1814 io.Copy(&snapshot, ringBuffer) 1815 return out, metadata, &smithy.DeserializationError{ 1816 Err: fmt.Errorf("failed to decode response body, %w", err), 1817 Snapshot: snapshot.Bytes(), 1818 } 1819 } 1820 1821 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1822 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(&output, decoder) 1823 if err != nil { 1824 var snapshot bytes.Buffer 1825 io.Copy(&snapshot, ringBuffer) 1826 return out, metadata, &smithy.DeserializationError{ 1827 Err: fmt.Errorf("failed to decode response body, %w", err), 1828 Snapshot: snapshot.Bytes(), 1829 } 1830 } 1831 1832 return out, metadata, err 1833} 1834 1835func awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1836 var errorBuffer bytes.Buffer 1837 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1838 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1839 } 1840 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1841 1842 errorCode := "UnknownError" 1843 errorMessage := errorCode 1844 1845 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1846 if err != nil { 1847 return err 1848 } 1849 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1850 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1851 } 1852 if len(errorComponents.Code) != 0 { 1853 errorCode = errorComponents.Code 1854 } 1855 if len(errorComponents.Message) != 0 { 1856 errorMessage = errorComponents.Message 1857 } 1858 errorBody.Seek(0, io.SeekStart) 1859 switch { 1860 case strings.EqualFold("ConcurrentModification", errorCode): 1861 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 1862 1863 case strings.EqualFold("InvalidInput", errorCode): 1864 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1865 1866 case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode): 1867 return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody) 1868 1869 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 1870 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 1871 1872 case strings.EqualFold("TooManyTrafficPolicyVersionsForCurrentPolicy", errorCode): 1873 return awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response, errorBody) 1874 1875 default: 1876 genericError := &smithy.GenericAPIError{ 1877 Code: errorCode, 1878 Message: errorMessage, 1879 } 1880 return genericError 1881 1882 } 1883} 1884 1885func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(v *CreateTrafficPolicyVersionOutput, response *smithyhttp.Response) error { 1886 if v == nil { 1887 return fmt.Errorf("unsupported deserialization for nil %T", v) 1888 } 1889 1890 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1891 headerValues[0] = strings.TrimSpace(headerValues[0]) 1892 v.Location = ptr.String(headerValues[0]) 1893 } 1894 1895 return nil 1896} 1897func awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(v **CreateTrafficPolicyVersionOutput, decoder smithyxml.NodeDecoder) error { 1898 if v == nil { 1899 return fmt.Errorf("unexpected nil of type %T", v) 1900 } 1901 var sv *CreateTrafficPolicyVersionOutput 1902 if *v == nil { 1903 sv = &CreateTrafficPolicyVersionOutput{} 1904 } else { 1905 sv = *v 1906 } 1907 1908 for { 1909 t, done, err := decoder.Token() 1910 if err != nil { 1911 return err 1912 } 1913 if done { 1914 break 1915 } 1916 originalDecoder := decoder 1917 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1918 switch { 1919 case strings.EqualFold("TrafficPolicy", t.Name.Local): 1920 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1921 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 1922 return err 1923 } 1924 1925 default: 1926 // Do nothing and ignore the unexpected tag element 1927 err = decoder.Decoder.Skip() 1928 if err != nil { 1929 return err 1930 } 1931 1932 } 1933 decoder = originalDecoder 1934 } 1935 *v = sv 1936 return nil 1937} 1938 1939type awsRestxml_deserializeOpCreateVPCAssociationAuthorization struct { 1940} 1941 1942func (*awsRestxml_deserializeOpCreateVPCAssociationAuthorization) ID() string { 1943 return "OperationDeserializer" 1944} 1945 1946func (m *awsRestxml_deserializeOpCreateVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1947 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1948) { 1949 out, metadata, err = next.HandleDeserialize(ctx, in) 1950 if err != nil { 1951 return out, metadata, err 1952 } 1953 1954 response, ok := out.RawResponse.(*smithyhttp.Response) 1955 if !ok { 1956 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1957 } 1958 1959 if response.StatusCode < 200 || response.StatusCode >= 300 { 1960 return out, metadata, awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response, &metadata) 1961 } 1962 output := &CreateVPCAssociationAuthorizationOutput{} 1963 out.Result = output 1964 1965 var buff [1024]byte 1966 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1967 body := io.TeeReader(response.Body, ringBuffer) 1968 rootDecoder := xml.NewDecoder(body) 1969 t, err := smithyxml.FetchRootElement(rootDecoder) 1970 if err == io.EOF { 1971 return out, metadata, nil 1972 } 1973 if err != nil { 1974 var snapshot bytes.Buffer 1975 io.Copy(&snapshot, ringBuffer) 1976 return out, metadata, &smithy.DeserializationError{ 1977 Err: fmt.Errorf("failed to decode response body, %w", err), 1978 Snapshot: snapshot.Bytes(), 1979 } 1980 } 1981 1982 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1983 err = awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(&output, decoder) 1984 if err != nil { 1985 var snapshot bytes.Buffer 1986 io.Copy(&snapshot, ringBuffer) 1987 return out, metadata, &smithy.DeserializationError{ 1988 Err: fmt.Errorf("failed to decode response body, %w", err), 1989 Snapshot: snapshot.Bytes(), 1990 } 1991 } 1992 1993 return out, metadata, err 1994} 1995 1996func awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1997 var errorBuffer bytes.Buffer 1998 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1999 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2000 } 2001 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2002 2003 errorCode := "UnknownError" 2004 errorMessage := errorCode 2005 2006 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2007 if err != nil { 2008 return err 2009 } 2010 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2011 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2012 } 2013 if len(errorComponents.Code) != 0 { 2014 errorCode = errorComponents.Code 2015 } 2016 if len(errorComponents.Message) != 0 { 2017 errorMessage = errorComponents.Message 2018 } 2019 errorBody.Seek(0, io.SeekStart) 2020 switch { 2021 case strings.EqualFold("ConcurrentModification", errorCode): 2022 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2023 2024 case strings.EqualFold("InvalidInput", errorCode): 2025 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2026 2027 case strings.EqualFold("InvalidVPCId", errorCode): 2028 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 2029 2030 case strings.EqualFold("NoSuchHostedZone", errorCode): 2031 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 2032 2033 case strings.EqualFold("TooManyVPCAssociationAuthorizations", errorCode): 2034 return awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response, errorBody) 2035 2036 default: 2037 genericError := &smithy.GenericAPIError{ 2038 Code: errorCode, 2039 Message: errorMessage, 2040 } 2041 return genericError 2042 2043 } 2044} 2045 2046func awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(v **CreateVPCAssociationAuthorizationOutput, decoder smithyxml.NodeDecoder) error { 2047 if v == nil { 2048 return fmt.Errorf("unexpected nil of type %T", v) 2049 } 2050 var sv *CreateVPCAssociationAuthorizationOutput 2051 if *v == nil { 2052 sv = &CreateVPCAssociationAuthorizationOutput{} 2053 } else { 2054 sv = *v 2055 } 2056 2057 for { 2058 t, done, err := decoder.Token() 2059 if err != nil { 2060 return err 2061 } 2062 if done { 2063 break 2064 } 2065 originalDecoder := decoder 2066 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2067 switch { 2068 case strings.EqualFold("HostedZoneId", t.Name.Local): 2069 val, err := decoder.Value() 2070 if err != nil { 2071 return err 2072 } 2073 if val == nil { 2074 break 2075 } 2076 { 2077 xtv := string(val) 2078 sv.HostedZoneId = ptr.String(xtv) 2079 } 2080 2081 case strings.EqualFold("VPC", t.Name.Local): 2082 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2083 if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil { 2084 return err 2085 } 2086 2087 default: 2088 // Do nothing and ignore the unexpected tag element 2089 err = decoder.Decoder.Skip() 2090 if err != nil { 2091 return err 2092 } 2093 2094 } 2095 decoder = originalDecoder 2096 } 2097 *v = sv 2098 return nil 2099} 2100 2101type awsRestxml_deserializeOpDeactivateKeySigningKey struct { 2102} 2103 2104func (*awsRestxml_deserializeOpDeactivateKeySigningKey) ID() string { 2105 return "OperationDeserializer" 2106} 2107 2108func (m *awsRestxml_deserializeOpDeactivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2109 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2110) { 2111 out, metadata, err = next.HandleDeserialize(ctx, in) 2112 if err != nil { 2113 return out, metadata, err 2114 } 2115 2116 response, ok := out.RawResponse.(*smithyhttp.Response) 2117 if !ok { 2118 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2119 } 2120 2121 if response.StatusCode < 200 || response.StatusCode >= 300 { 2122 return out, metadata, awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response, &metadata) 2123 } 2124 output := &DeactivateKeySigningKeyOutput{} 2125 out.Result = output 2126 2127 var buff [1024]byte 2128 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2129 body := io.TeeReader(response.Body, ringBuffer) 2130 rootDecoder := xml.NewDecoder(body) 2131 t, err := smithyxml.FetchRootElement(rootDecoder) 2132 if err == io.EOF { 2133 return out, metadata, nil 2134 } 2135 if err != nil { 2136 var snapshot bytes.Buffer 2137 io.Copy(&snapshot, ringBuffer) 2138 return out, metadata, &smithy.DeserializationError{ 2139 Err: fmt.Errorf("failed to decode response body, %w", err), 2140 Snapshot: snapshot.Bytes(), 2141 } 2142 } 2143 2144 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2145 err = awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(&output, decoder) 2146 if err != nil { 2147 var snapshot bytes.Buffer 2148 io.Copy(&snapshot, ringBuffer) 2149 return out, metadata, &smithy.DeserializationError{ 2150 Err: fmt.Errorf("failed to decode response body, %w", err), 2151 Snapshot: snapshot.Bytes(), 2152 } 2153 } 2154 2155 return out, metadata, err 2156} 2157 2158func awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2159 var errorBuffer bytes.Buffer 2160 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2161 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2162 } 2163 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2164 2165 errorCode := "UnknownError" 2166 errorMessage := errorCode 2167 2168 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2169 if err != nil { 2170 return err 2171 } 2172 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2173 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2174 } 2175 if len(errorComponents.Code) != 0 { 2176 errorCode = errorComponents.Code 2177 } 2178 if len(errorComponents.Message) != 0 { 2179 errorMessage = errorComponents.Message 2180 } 2181 errorBody.Seek(0, io.SeekStart) 2182 switch { 2183 case strings.EqualFold("ConcurrentModification", errorCode): 2184 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2185 2186 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 2187 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 2188 2189 case strings.EqualFold("InvalidSigningStatus", errorCode): 2190 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 2191 2192 case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode): 2193 return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody) 2194 2195 case strings.EqualFold("KeySigningKeyInUse", errorCode): 2196 return awsRestxml_deserializeErrorKeySigningKeyInUse(response, errorBody) 2197 2198 case strings.EqualFold("NoSuchKeySigningKey", errorCode): 2199 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody) 2200 2201 default: 2202 genericError := &smithy.GenericAPIError{ 2203 Code: errorCode, 2204 Message: errorMessage, 2205 } 2206 return genericError 2207 2208 } 2209} 2210 2211func awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(v **DeactivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 2212 if v == nil { 2213 return fmt.Errorf("unexpected nil of type %T", v) 2214 } 2215 var sv *DeactivateKeySigningKeyOutput 2216 if *v == nil { 2217 sv = &DeactivateKeySigningKeyOutput{} 2218 } else { 2219 sv = *v 2220 } 2221 2222 for { 2223 t, done, err := decoder.Token() 2224 if err != nil { 2225 return err 2226 } 2227 if done { 2228 break 2229 } 2230 originalDecoder := decoder 2231 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2232 switch { 2233 case strings.EqualFold("ChangeInfo", t.Name.Local): 2234 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2235 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 2236 return err 2237 } 2238 2239 default: 2240 // Do nothing and ignore the unexpected tag element 2241 err = decoder.Decoder.Skip() 2242 if err != nil { 2243 return err 2244 } 2245 2246 } 2247 decoder = originalDecoder 2248 } 2249 *v = sv 2250 return nil 2251} 2252 2253type awsRestxml_deserializeOpDeleteHealthCheck struct { 2254} 2255 2256func (*awsRestxml_deserializeOpDeleteHealthCheck) ID() string { 2257 return "OperationDeserializer" 2258} 2259 2260func (m *awsRestxml_deserializeOpDeleteHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2262) { 2263 out, metadata, err = next.HandleDeserialize(ctx, in) 2264 if err != nil { 2265 return out, metadata, err 2266 } 2267 2268 response, ok := out.RawResponse.(*smithyhttp.Response) 2269 if !ok { 2270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2271 } 2272 2273 if response.StatusCode < 200 || response.StatusCode >= 300 { 2274 return out, metadata, awsRestxml_deserializeOpErrorDeleteHealthCheck(response, &metadata) 2275 } 2276 output := &DeleteHealthCheckOutput{} 2277 out.Result = output 2278 2279 return out, metadata, err 2280} 2281 2282func awsRestxml_deserializeOpErrorDeleteHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2283 var errorBuffer bytes.Buffer 2284 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2285 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2286 } 2287 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2288 2289 errorCode := "UnknownError" 2290 errorMessage := errorCode 2291 2292 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2293 if err != nil { 2294 return err 2295 } 2296 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2297 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2298 } 2299 if len(errorComponents.Code) != 0 { 2300 errorCode = errorComponents.Code 2301 } 2302 if len(errorComponents.Message) != 0 { 2303 errorMessage = errorComponents.Message 2304 } 2305 errorBody.Seek(0, io.SeekStart) 2306 switch { 2307 case strings.EqualFold("HealthCheckInUse", errorCode): 2308 return awsRestxml_deserializeErrorHealthCheckInUse(response, errorBody) 2309 2310 case strings.EqualFold("InvalidInput", errorCode): 2311 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2312 2313 case strings.EqualFold("NoSuchHealthCheck", errorCode): 2314 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 2315 2316 default: 2317 genericError := &smithy.GenericAPIError{ 2318 Code: errorCode, 2319 Message: errorMessage, 2320 } 2321 return genericError 2322 2323 } 2324} 2325 2326type awsRestxml_deserializeOpDeleteHostedZone struct { 2327} 2328 2329func (*awsRestxml_deserializeOpDeleteHostedZone) ID() string { 2330 return "OperationDeserializer" 2331} 2332 2333func (m *awsRestxml_deserializeOpDeleteHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2334 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2335) { 2336 out, metadata, err = next.HandleDeserialize(ctx, in) 2337 if err != nil { 2338 return out, metadata, err 2339 } 2340 2341 response, ok := out.RawResponse.(*smithyhttp.Response) 2342 if !ok { 2343 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2344 } 2345 2346 if response.StatusCode < 200 || response.StatusCode >= 300 { 2347 return out, metadata, awsRestxml_deserializeOpErrorDeleteHostedZone(response, &metadata) 2348 } 2349 output := &DeleteHostedZoneOutput{} 2350 out.Result = output 2351 2352 var buff [1024]byte 2353 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2354 body := io.TeeReader(response.Body, ringBuffer) 2355 rootDecoder := xml.NewDecoder(body) 2356 t, err := smithyxml.FetchRootElement(rootDecoder) 2357 if err == io.EOF { 2358 return out, metadata, nil 2359 } 2360 if err != nil { 2361 var snapshot bytes.Buffer 2362 io.Copy(&snapshot, ringBuffer) 2363 return out, metadata, &smithy.DeserializationError{ 2364 Err: fmt.Errorf("failed to decode response body, %w", err), 2365 Snapshot: snapshot.Bytes(), 2366 } 2367 } 2368 2369 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2370 err = awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(&output, decoder) 2371 if err != nil { 2372 var snapshot bytes.Buffer 2373 io.Copy(&snapshot, ringBuffer) 2374 return out, metadata, &smithy.DeserializationError{ 2375 Err: fmt.Errorf("failed to decode response body, %w", err), 2376 Snapshot: snapshot.Bytes(), 2377 } 2378 } 2379 2380 return out, metadata, err 2381} 2382 2383func awsRestxml_deserializeOpErrorDeleteHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2384 var errorBuffer bytes.Buffer 2385 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2386 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2387 } 2388 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2389 2390 errorCode := "UnknownError" 2391 errorMessage := errorCode 2392 2393 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2394 if err != nil { 2395 return err 2396 } 2397 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2398 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2399 } 2400 if len(errorComponents.Code) != 0 { 2401 errorCode = errorComponents.Code 2402 } 2403 if len(errorComponents.Message) != 0 { 2404 errorMessage = errorComponents.Message 2405 } 2406 errorBody.Seek(0, io.SeekStart) 2407 switch { 2408 case strings.EqualFold("HostedZoneNotEmpty", errorCode): 2409 return awsRestxml_deserializeErrorHostedZoneNotEmpty(response, errorBody) 2410 2411 case strings.EqualFold("InvalidDomainName", errorCode): 2412 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody) 2413 2414 case strings.EqualFold("InvalidInput", errorCode): 2415 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2416 2417 case strings.EqualFold("NoSuchHostedZone", errorCode): 2418 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 2419 2420 case strings.EqualFold("PriorRequestNotComplete", errorCode): 2421 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 2422 2423 default: 2424 genericError := &smithy.GenericAPIError{ 2425 Code: errorCode, 2426 Message: errorMessage, 2427 } 2428 return genericError 2429 2430 } 2431} 2432 2433func awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(v **DeleteHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 2434 if v == nil { 2435 return fmt.Errorf("unexpected nil of type %T", v) 2436 } 2437 var sv *DeleteHostedZoneOutput 2438 if *v == nil { 2439 sv = &DeleteHostedZoneOutput{} 2440 } else { 2441 sv = *v 2442 } 2443 2444 for { 2445 t, done, err := decoder.Token() 2446 if err != nil { 2447 return err 2448 } 2449 if done { 2450 break 2451 } 2452 originalDecoder := decoder 2453 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2454 switch { 2455 case strings.EqualFold("ChangeInfo", t.Name.Local): 2456 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2457 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 2458 return err 2459 } 2460 2461 default: 2462 // Do nothing and ignore the unexpected tag element 2463 err = decoder.Decoder.Skip() 2464 if err != nil { 2465 return err 2466 } 2467 2468 } 2469 decoder = originalDecoder 2470 } 2471 *v = sv 2472 return nil 2473} 2474 2475type awsRestxml_deserializeOpDeleteKeySigningKey struct { 2476} 2477 2478func (*awsRestxml_deserializeOpDeleteKeySigningKey) ID() string { 2479 return "OperationDeserializer" 2480} 2481 2482func (m *awsRestxml_deserializeOpDeleteKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2483 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2484) { 2485 out, metadata, err = next.HandleDeserialize(ctx, in) 2486 if err != nil { 2487 return out, metadata, err 2488 } 2489 2490 response, ok := out.RawResponse.(*smithyhttp.Response) 2491 if !ok { 2492 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2493 } 2494 2495 if response.StatusCode < 200 || response.StatusCode >= 300 { 2496 return out, metadata, awsRestxml_deserializeOpErrorDeleteKeySigningKey(response, &metadata) 2497 } 2498 output := &DeleteKeySigningKeyOutput{} 2499 out.Result = output 2500 2501 var buff [1024]byte 2502 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2503 body := io.TeeReader(response.Body, ringBuffer) 2504 rootDecoder := xml.NewDecoder(body) 2505 t, err := smithyxml.FetchRootElement(rootDecoder) 2506 if err == io.EOF { 2507 return out, metadata, nil 2508 } 2509 if err != nil { 2510 var snapshot bytes.Buffer 2511 io.Copy(&snapshot, ringBuffer) 2512 return out, metadata, &smithy.DeserializationError{ 2513 Err: fmt.Errorf("failed to decode response body, %w", err), 2514 Snapshot: snapshot.Bytes(), 2515 } 2516 } 2517 2518 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2519 err = awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(&output, decoder) 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 return out, metadata, err 2530} 2531 2532func awsRestxml_deserializeOpErrorDeleteKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2533 var errorBuffer bytes.Buffer 2534 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2535 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2536 } 2537 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2538 2539 errorCode := "UnknownError" 2540 errorMessage := errorCode 2541 2542 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2543 if err != nil { 2544 return err 2545 } 2546 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2547 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2548 } 2549 if len(errorComponents.Code) != 0 { 2550 errorCode = errorComponents.Code 2551 } 2552 if len(errorComponents.Message) != 0 { 2553 errorMessage = errorComponents.Message 2554 } 2555 errorBody.Seek(0, io.SeekStart) 2556 switch { 2557 case strings.EqualFold("ConcurrentModification", errorCode): 2558 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2559 2560 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 2561 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 2562 2563 case strings.EqualFold("InvalidKMSArn", errorCode): 2564 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 2565 2566 case strings.EqualFold("InvalidSigningStatus", errorCode): 2567 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 2568 2569 case strings.EqualFold("NoSuchKeySigningKey", errorCode): 2570 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody) 2571 2572 default: 2573 genericError := &smithy.GenericAPIError{ 2574 Code: errorCode, 2575 Message: errorMessage, 2576 } 2577 return genericError 2578 2579 } 2580} 2581 2582func awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(v **DeleteKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 2583 if v == nil { 2584 return fmt.Errorf("unexpected nil of type %T", v) 2585 } 2586 var sv *DeleteKeySigningKeyOutput 2587 if *v == nil { 2588 sv = &DeleteKeySigningKeyOutput{} 2589 } else { 2590 sv = *v 2591 } 2592 2593 for { 2594 t, done, err := decoder.Token() 2595 if err != nil { 2596 return err 2597 } 2598 if done { 2599 break 2600 } 2601 originalDecoder := decoder 2602 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2603 switch { 2604 case strings.EqualFold("ChangeInfo", t.Name.Local): 2605 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2606 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 2607 return err 2608 } 2609 2610 default: 2611 // Do nothing and ignore the unexpected tag element 2612 err = decoder.Decoder.Skip() 2613 if err != nil { 2614 return err 2615 } 2616 2617 } 2618 decoder = originalDecoder 2619 } 2620 *v = sv 2621 return nil 2622} 2623 2624type awsRestxml_deserializeOpDeleteQueryLoggingConfig struct { 2625} 2626 2627func (*awsRestxml_deserializeOpDeleteQueryLoggingConfig) ID() string { 2628 return "OperationDeserializer" 2629} 2630 2631func (m *awsRestxml_deserializeOpDeleteQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2632 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2633) { 2634 out, metadata, err = next.HandleDeserialize(ctx, in) 2635 if err != nil { 2636 return out, metadata, err 2637 } 2638 2639 response, ok := out.RawResponse.(*smithyhttp.Response) 2640 if !ok { 2641 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2642 } 2643 2644 if response.StatusCode < 200 || response.StatusCode >= 300 { 2645 return out, metadata, awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response, &metadata) 2646 } 2647 output := &DeleteQueryLoggingConfigOutput{} 2648 out.Result = output 2649 2650 return out, metadata, err 2651} 2652 2653func awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2654 var errorBuffer bytes.Buffer 2655 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2656 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2657 } 2658 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2659 2660 errorCode := "UnknownError" 2661 errorMessage := errorCode 2662 2663 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2664 if err != nil { 2665 return err 2666 } 2667 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2668 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2669 } 2670 if len(errorComponents.Code) != 0 { 2671 errorCode = errorComponents.Code 2672 } 2673 if len(errorComponents.Message) != 0 { 2674 errorMessage = errorComponents.Message 2675 } 2676 errorBody.Seek(0, io.SeekStart) 2677 switch { 2678 case strings.EqualFold("ConcurrentModification", errorCode): 2679 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2680 2681 case strings.EqualFold("InvalidInput", errorCode): 2682 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2683 2684 case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode): 2685 return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody) 2686 2687 default: 2688 genericError := &smithy.GenericAPIError{ 2689 Code: errorCode, 2690 Message: errorMessage, 2691 } 2692 return genericError 2693 2694 } 2695} 2696 2697type awsRestxml_deserializeOpDeleteReusableDelegationSet struct { 2698} 2699 2700func (*awsRestxml_deserializeOpDeleteReusableDelegationSet) ID() string { 2701 return "OperationDeserializer" 2702} 2703 2704func (m *awsRestxml_deserializeOpDeleteReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2705 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2706) { 2707 out, metadata, err = next.HandleDeserialize(ctx, in) 2708 if err != nil { 2709 return out, metadata, err 2710 } 2711 2712 response, ok := out.RawResponse.(*smithyhttp.Response) 2713 if !ok { 2714 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2715 } 2716 2717 if response.StatusCode < 200 || response.StatusCode >= 300 { 2718 return out, metadata, awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response, &metadata) 2719 } 2720 output := &DeleteReusableDelegationSetOutput{} 2721 out.Result = output 2722 2723 return out, metadata, err 2724} 2725 2726func awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2727 var errorBuffer bytes.Buffer 2728 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2729 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2730 } 2731 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2732 2733 errorCode := "UnknownError" 2734 errorMessage := errorCode 2735 2736 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2737 if err != nil { 2738 return err 2739 } 2740 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2741 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2742 } 2743 if len(errorComponents.Code) != 0 { 2744 errorCode = errorComponents.Code 2745 } 2746 if len(errorComponents.Message) != 0 { 2747 errorMessage = errorComponents.Message 2748 } 2749 errorBody.Seek(0, io.SeekStart) 2750 switch { 2751 case strings.EqualFold("DelegationSetInUse", errorCode): 2752 return awsRestxml_deserializeErrorDelegationSetInUse(response, errorBody) 2753 2754 case strings.EqualFold("DelegationSetNotReusable", errorCode): 2755 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 2756 2757 case strings.EqualFold("InvalidInput", errorCode): 2758 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2759 2760 case strings.EqualFold("NoSuchDelegationSet", errorCode): 2761 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 2762 2763 default: 2764 genericError := &smithy.GenericAPIError{ 2765 Code: errorCode, 2766 Message: errorMessage, 2767 } 2768 return genericError 2769 2770 } 2771} 2772 2773type awsRestxml_deserializeOpDeleteTrafficPolicy struct { 2774} 2775 2776func (*awsRestxml_deserializeOpDeleteTrafficPolicy) ID() string { 2777 return "OperationDeserializer" 2778} 2779 2780func (m *awsRestxml_deserializeOpDeleteTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2781 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2782) { 2783 out, metadata, err = next.HandleDeserialize(ctx, in) 2784 if err != nil { 2785 return out, metadata, err 2786 } 2787 2788 response, ok := out.RawResponse.(*smithyhttp.Response) 2789 if !ok { 2790 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2791 } 2792 2793 if response.StatusCode < 200 || response.StatusCode >= 300 { 2794 return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response, &metadata) 2795 } 2796 output := &DeleteTrafficPolicyOutput{} 2797 out.Result = output 2798 2799 return out, metadata, err 2800} 2801 2802func awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2803 var errorBuffer bytes.Buffer 2804 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2805 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2806 } 2807 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2808 2809 errorCode := "UnknownError" 2810 errorMessage := errorCode 2811 2812 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2813 if err != nil { 2814 return err 2815 } 2816 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2817 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2818 } 2819 if len(errorComponents.Code) != 0 { 2820 errorCode = errorComponents.Code 2821 } 2822 if len(errorComponents.Message) != 0 { 2823 errorMessage = errorComponents.Message 2824 } 2825 errorBody.Seek(0, io.SeekStart) 2826 switch { 2827 case strings.EqualFold("ConcurrentModification", errorCode): 2828 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2829 2830 case strings.EqualFold("InvalidInput", errorCode): 2831 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2832 2833 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 2834 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 2835 2836 case strings.EqualFold("TrafficPolicyInUse", errorCode): 2837 return awsRestxml_deserializeErrorTrafficPolicyInUse(response, errorBody) 2838 2839 default: 2840 genericError := &smithy.GenericAPIError{ 2841 Code: errorCode, 2842 Message: errorMessage, 2843 } 2844 return genericError 2845 2846 } 2847} 2848 2849type awsRestxml_deserializeOpDeleteTrafficPolicyInstance struct { 2850} 2851 2852func (*awsRestxml_deserializeOpDeleteTrafficPolicyInstance) ID() string { 2853 return "OperationDeserializer" 2854} 2855 2856func (m *awsRestxml_deserializeOpDeleteTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2857 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2858) { 2859 out, metadata, err = next.HandleDeserialize(ctx, in) 2860 if err != nil { 2861 return out, metadata, err 2862 } 2863 2864 response, ok := out.RawResponse.(*smithyhttp.Response) 2865 if !ok { 2866 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2867 } 2868 2869 if response.StatusCode < 200 || response.StatusCode >= 300 { 2870 return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response, &metadata) 2871 } 2872 output := &DeleteTrafficPolicyInstanceOutput{} 2873 out.Result = output 2874 2875 return out, metadata, err 2876} 2877 2878func awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2879 var errorBuffer bytes.Buffer 2880 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2881 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2882 } 2883 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2884 2885 errorCode := "UnknownError" 2886 errorMessage := errorCode 2887 2888 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2889 if err != nil { 2890 return err 2891 } 2892 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2893 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2894 } 2895 if len(errorComponents.Code) != 0 { 2896 errorCode = errorComponents.Code 2897 } 2898 if len(errorComponents.Message) != 0 { 2899 errorMessage = errorComponents.Message 2900 } 2901 errorBody.Seek(0, io.SeekStart) 2902 switch { 2903 case strings.EqualFold("InvalidInput", errorCode): 2904 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2905 2906 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 2907 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 2908 2909 case strings.EqualFold("PriorRequestNotComplete", errorCode): 2910 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 2911 2912 default: 2913 genericError := &smithy.GenericAPIError{ 2914 Code: errorCode, 2915 Message: errorMessage, 2916 } 2917 return genericError 2918 2919 } 2920} 2921 2922type awsRestxml_deserializeOpDeleteVPCAssociationAuthorization struct { 2923} 2924 2925func (*awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) ID() string { 2926 return "OperationDeserializer" 2927} 2928 2929func (m *awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2930 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2931) { 2932 out, metadata, err = next.HandleDeserialize(ctx, in) 2933 if err != nil { 2934 return out, metadata, err 2935 } 2936 2937 response, ok := out.RawResponse.(*smithyhttp.Response) 2938 if !ok { 2939 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2940 } 2941 2942 if response.StatusCode < 200 || response.StatusCode >= 300 { 2943 return out, metadata, awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response, &metadata) 2944 } 2945 output := &DeleteVPCAssociationAuthorizationOutput{} 2946 out.Result = output 2947 2948 return out, metadata, err 2949} 2950 2951func awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2952 var errorBuffer bytes.Buffer 2953 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2954 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2955 } 2956 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2957 2958 errorCode := "UnknownError" 2959 errorMessage := errorCode 2960 2961 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2962 if err != nil { 2963 return err 2964 } 2965 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2966 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2967 } 2968 if len(errorComponents.Code) != 0 { 2969 errorCode = errorComponents.Code 2970 } 2971 if len(errorComponents.Message) != 0 { 2972 errorMessage = errorComponents.Message 2973 } 2974 errorBody.Seek(0, io.SeekStart) 2975 switch { 2976 case strings.EqualFold("ConcurrentModification", errorCode): 2977 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2978 2979 case strings.EqualFold("InvalidInput", errorCode): 2980 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2981 2982 case strings.EqualFold("InvalidVPCId", errorCode): 2983 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 2984 2985 case strings.EqualFold("NoSuchHostedZone", errorCode): 2986 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 2987 2988 case strings.EqualFold("VPCAssociationAuthorizationNotFound", errorCode): 2989 return awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response, errorBody) 2990 2991 default: 2992 genericError := &smithy.GenericAPIError{ 2993 Code: errorCode, 2994 Message: errorMessage, 2995 } 2996 return genericError 2997 2998 } 2999} 3000 3001type awsRestxml_deserializeOpDisableHostedZoneDNSSEC struct { 3002} 3003 3004func (*awsRestxml_deserializeOpDisableHostedZoneDNSSEC) ID() string { 3005 return "OperationDeserializer" 3006} 3007 3008func (m *awsRestxml_deserializeOpDisableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3009 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3010) { 3011 out, metadata, err = next.HandleDeserialize(ctx, in) 3012 if err != nil { 3013 return out, metadata, err 3014 } 3015 3016 response, ok := out.RawResponse.(*smithyhttp.Response) 3017 if !ok { 3018 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3019 } 3020 3021 if response.StatusCode < 200 || response.StatusCode >= 300 { 3022 return out, metadata, awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response, &metadata) 3023 } 3024 output := &DisableHostedZoneDNSSECOutput{} 3025 out.Result = output 3026 3027 var buff [1024]byte 3028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3029 body := io.TeeReader(response.Body, ringBuffer) 3030 rootDecoder := xml.NewDecoder(body) 3031 t, err := smithyxml.FetchRootElement(rootDecoder) 3032 if err == io.EOF { 3033 return out, metadata, nil 3034 } 3035 if err != nil { 3036 var snapshot bytes.Buffer 3037 io.Copy(&snapshot, ringBuffer) 3038 return out, metadata, &smithy.DeserializationError{ 3039 Err: fmt.Errorf("failed to decode response body, %w", err), 3040 Snapshot: snapshot.Bytes(), 3041 } 3042 } 3043 3044 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3045 err = awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(&output, decoder) 3046 if err != nil { 3047 var snapshot bytes.Buffer 3048 io.Copy(&snapshot, ringBuffer) 3049 return out, metadata, &smithy.DeserializationError{ 3050 Err: fmt.Errorf("failed to decode response body, %w", err), 3051 Snapshot: snapshot.Bytes(), 3052 } 3053 } 3054 3055 return out, metadata, err 3056} 3057 3058func awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3059 var errorBuffer bytes.Buffer 3060 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3061 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3062 } 3063 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3064 3065 errorCode := "UnknownError" 3066 errorMessage := errorCode 3067 3068 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3069 if err != nil { 3070 return err 3071 } 3072 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3073 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3074 } 3075 if len(errorComponents.Code) != 0 { 3076 errorCode = errorComponents.Code 3077 } 3078 if len(errorComponents.Message) != 0 { 3079 errorMessage = errorComponents.Message 3080 } 3081 errorBody.Seek(0, io.SeekStart) 3082 switch { 3083 case strings.EqualFold("ConcurrentModification", errorCode): 3084 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 3085 3086 case strings.EqualFold("DNSSECNotFound", errorCode): 3087 return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody) 3088 3089 case strings.EqualFold("InvalidArgument", errorCode): 3090 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 3091 3092 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 3093 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 3094 3095 case strings.EqualFold("InvalidKMSArn", errorCode): 3096 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 3097 3098 case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode): 3099 return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody) 3100 3101 case strings.EqualFold("NoSuchHostedZone", errorCode): 3102 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3103 3104 default: 3105 genericError := &smithy.GenericAPIError{ 3106 Code: errorCode, 3107 Message: errorMessage, 3108 } 3109 return genericError 3110 3111 } 3112} 3113 3114func awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(v **DisableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error { 3115 if v == nil { 3116 return fmt.Errorf("unexpected nil of type %T", v) 3117 } 3118 var sv *DisableHostedZoneDNSSECOutput 3119 if *v == nil { 3120 sv = &DisableHostedZoneDNSSECOutput{} 3121 } else { 3122 sv = *v 3123 } 3124 3125 for { 3126 t, done, err := decoder.Token() 3127 if err != nil { 3128 return err 3129 } 3130 if done { 3131 break 3132 } 3133 originalDecoder := decoder 3134 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3135 switch { 3136 case strings.EqualFold("ChangeInfo", t.Name.Local): 3137 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3138 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3139 return err 3140 } 3141 3142 default: 3143 // Do nothing and ignore the unexpected tag element 3144 err = decoder.Decoder.Skip() 3145 if err != nil { 3146 return err 3147 } 3148 3149 } 3150 decoder = originalDecoder 3151 } 3152 *v = sv 3153 return nil 3154} 3155 3156type awsRestxml_deserializeOpDisassociateVPCFromHostedZone struct { 3157} 3158 3159func (*awsRestxml_deserializeOpDisassociateVPCFromHostedZone) ID() string { 3160 return "OperationDeserializer" 3161} 3162 3163func (m *awsRestxml_deserializeOpDisassociateVPCFromHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3164 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3165) { 3166 out, metadata, err = next.HandleDeserialize(ctx, in) 3167 if err != nil { 3168 return out, metadata, err 3169 } 3170 3171 response, ok := out.RawResponse.(*smithyhttp.Response) 3172 if !ok { 3173 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3174 } 3175 3176 if response.StatusCode < 200 || response.StatusCode >= 300 { 3177 return out, metadata, awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response, &metadata) 3178 } 3179 output := &DisassociateVPCFromHostedZoneOutput{} 3180 out.Result = output 3181 3182 var buff [1024]byte 3183 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3184 body := io.TeeReader(response.Body, ringBuffer) 3185 rootDecoder := xml.NewDecoder(body) 3186 t, err := smithyxml.FetchRootElement(rootDecoder) 3187 if err == io.EOF { 3188 return out, metadata, nil 3189 } 3190 if err != nil { 3191 var snapshot bytes.Buffer 3192 io.Copy(&snapshot, ringBuffer) 3193 return out, metadata, &smithy.DeserializationError{ 3194 Err: fmt.Errorf("failed to decode response body, %w", err), 3195 Snapshot: snapshot.Bytes(), 3196 } 3197 } 3198 3199 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3200 err = awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(&output, decoder) 3201 if err != nil { 3202 var snapshot bytes.Buffer 3203 io.Copy(&snapshot, ringBuffer) 3204 return out, metadata, &smithy.DeserializationError{ 3205 Err: fmt.Errorf("failed to decode response body, %w", err), 3206 Snapshot: snapshot.Bytes(), 3207 } 3208 } 3209 3210 return out, metadata, err 3211} 3212 3213func awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3214 var errorBuffer bytes.Buffer 3215 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3216 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3217 } 3218 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3219 3220 errorCode := "UnknownError" 3221 errorMessage := errorCode 3222 3223 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3224 if err != nil { 3225 return err 3226 } 3227 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3228 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3229 } 3230 if len(errorComponents.Code) != 0 { 3231 errorCode = errorComponents.Code 3232 } 3233 if len(errorComponents.Message) != 0 { 3234 errorMessage = errorComponents.Message 3235 } 3236 errorBody.Seek(0, io.SeekStart) 3237 switch { 3238 case strings.EqualFold("InvalidInput", errorCode): 3239 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3240 3241 case strings.EqualFold("InvalidVPCId", errorCode): 3242 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 3243 3244 case strings.EqualFold("LastVPCAssociation", errorCode): 3245 return awsRestxml_deserializeErrorLastVPCAssociation(response, errorBody) 3246 3247 case strings.EqualFold("NoSuchHostedZone", errorCode): 3248 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3249 3250 case strings.EqualFold("VPCAssociationNotFound", errorCode): 3251 return awsRestxml_deserializeErrorVPCAssociationNotFound(response, errorBody) 3252 3253 default: 3254 genericError := &smithy.GenericAPIError{ 3255 Code: errorCode, 3256 Message: errorMessage, 3257 } 3258 return genericError 3259 3260 } 3261} 3262 3263func awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(v **DisassociateVPCFromHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 3264 if v == nil { 3265 return fmt.Errorf("unexpected nil of type %T", v) 3266 } 3267 var sv *DisassociateVPCFromHostedZoneOutput 3268 if *v == nil { 3269 sv = &DisassociateVPCFromHostedZoneOutput{} 3270 } else { 3271 sv = *v 3272 } 3273 3274 for { 3275 t, done, err := decoder.Token() 3276 if err != nil { 3277 return err 3278 } 3279 if done { 3280 break 3281 } 3282 originalDecoder := decoder 3283 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3284 switch { 3285 case strings.EqualFold("ChangeInfo", t.Name.Local): 3286 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3287 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3288 return err 3289 } 3290 3291 default: 3292 // Do nothing and ignore the unexpected tag element 3293 err = decoder.Decoder.Skip() 3294 if err != nil { 3295 return err 3296 } 3297 3298 } 3299 decoder = originalDecoder 3300 } 3301 *v = sv 3302 return nil 3303} 3304 3305type awsRestxml_deserializeOpEnableHostedZoneDNSSEC struct { 3306} 3307 3308func (*awsRestxml_deserializeOpEnableHostedZoneDNSSEC) ID() string { 3309 return "OperationDeserializer" 3310} 3311 3312func (m *awsRestxml_deserializeOpEnableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3313 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3314) { 3315 out, metadata, err = next.HandleDeserialize(ctx, in) 3316 if err != nil { 3317 return out, metadata, err 3318 } 3319 3320 response, ok := out.RawResponse.(*smithyhttp.Response) 3321 if !ok { 3322 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3323 } 3324 3325 if response.StatusCode < 200 || response.StatusCode >= 300 { 3326 return out, metadata, awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response, &metadata) 3327 } 3328 output := &EnableHostedZoneDNSSECOutput{} 3329 out.Result = output 3330 3331 var buff [1024]byte 3332 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3333 body := io.TeeReader(response.Body, ringBuffer) 3334 rootDecoder := xml.NewDecoder(body) 3335 t, err := smithyxml.FetchRootElement(rootDecoder) 3336 if err == io.EOF { 3337 return out, metadata, nil 3338 } 3339 if err != nil { 3340 var snapshot bytes.Buffer 3341 io.Copy(&snapshot, ringBuffer) 3342 return out, metadata, &smithy.DeserializationError{ 3343 Err: fmt.Errorf("failed to decode response body, %w", err), 3344 Snapshot: snapshot.Bytes(), 3345 } 3346 } 3347 3348 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3349 err = awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(&output, decoder) 3350 if err != nil { 3351 var snapshot bytes.Buffer 3352 io.Copy(&snapshot, ringBuffer) 3353 return out, metadata, &smithy.DeserializationError{ 3354 Err: fmt.Errorf("failed to decode response body, %w", err), 3355 Snapshot: snapshot.Bytes(), 3356 } 3357 } 3358 3359 return out, metadata, err 3360} 3361 3362func awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3363 var errorBuffer bytes.Buffer 3364 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3365 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3366 } 3367 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3368 3369 errorCode := "UnknownError" 3370 errorMessage := errorCode 3371 3372 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3373 if err != nil { 3374 return err 3375 } 3376 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3377 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3378 } 3379 if len(errorComponents.Code) != 0 { 3380 errorCode = errorComponents.Code 3381 } 3382 if len(errorComponents.Message) != 0 { 3383 errorMessage = errorComponents.Message 3384 } 3385 errorBody.Seek(0, io.SeekStart) 3386 switch { 3387 case strings.EqualFold("ConcurrentModification", errorCode): 3388 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 3389 3390 case strings.EqualFold("DNSSECNotFound", errorCode): 3391 return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody) 3392 3393 case strings.EqualFold("HostedZonePartiallyDelegated", errorCode): 3394 return awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response, errorBody) 3395 3396 case strings.EqualFold("InvalidArgument", errorCode): 3397 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 3398 3399 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 3400 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 3401 3402 case strings.EqualFold("InvalidKMSArn", errorCode): 3403 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 3404 3405 case strings.EqualFold("KeySigningKeyWithActiveStatusNotFound", errorCode): 3406 return awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response, errorBody) 3407 3408 case strings.EqualFold("NoSuchHostedZone", errorCode): 3409 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3410 3411 default: 3412 genericError := &smithy.GenericAPIError{ 3413 Code: errorCode, 3414 Message: errorMessage, 3415 } 3416 return genericError 3417 3418 } 3419} 3420 3421func awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(v **EnableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error { 3422 if v == nil { 3423 return fmt.Errorf("unexpected nil of type %T", v) 3424 } 3425 var sv *EnableHostedZoneDNSSECOutput 3426 if *v == nil { 3427 sv = &EnableHostedZoneDNSSECOutput{} 3428 } else { 3429 sv = *v 3430 } 3431 3432 for { 3433 t, done, err := decoder.Token() 3434 if err != nil { 3435 return err 3436 } 3437 if done { 3438 break 3439 } 3440 originalDecoder := decoder 3441 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3442 switch { 3443 case strings.EqualFold("ChangeInfo", t.Name.Local): 3444 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3445 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3446 return err 3447 } 3448 3449 default: 3450 // Do nothing and ignore the unexpected tag element 3451 err = decoder.Decoder.Skip() 3452 if err != nil { 3453 return err 3454 } 3455 3456 } 3457 decoder = originalDecoder 3458 } 3459 *v = sv 3460 return nil 3461} 3462 3463type awsRestxml_deserializeOpGetAccountLimit struct { 3464} 3465 3466func (*awsRestxml_deserializeOpGetAccountLimit) ID() string { 3467 return "OperationDeserializer" 3468} 3469 3470func (m *awsRestxml_deserializeOpGetAccountLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3471 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3472) { 3473 out, metadata, err = next.HandleDeserialize(ctx, in) 3474 if err != nil { 3475 return out, metadata, err 3476 } 3477 3478 response, ok := out.RawResponse.(*smithyhttp.Response) 3479 if !ok { 3480 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3481 } 3482 3483 if response.StatusCode < 200 || response.StatusCode >= 300 { 3484 return out, metadata, awsRestxml_deserializeOpErrorGetAccountLimit(response, &metadata) 3485 } 3486 output := &GetAccountLimitOutput{} 3487 out.Result = output 3488 3489 var buff [1024]byte 3490 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3491 body := io.TeeReader(response.Body, ringBuffer) 3492 rootDecoder := xml.NewDecoder(body) 3493 t, err := smithyxml.FetchRootElement(rootDecoder) 3494 if err == io.EOF { 3495 return out, metadata, nil 3496 } 3497 if err != nil { 3498 var snapshot bytes.Buffer 3499 io.Copy(&snapshot, ringBuffer) 3500 return out, metadata, &smithy.DeserializationError{ 3501 Err: fmt.Errorf("failed to decode response body, %w", err), 3502 Snapshot: snapshot.Bytes(), 3503 } 3504 } 3505 3506 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3507 err = awsRestxml_deserializeOpDocumentGetAccountLimitOutput(&output, decoder) 3508 if err != nil { 3509 var snapshot bytes.Buffer 3510 io.Copy(&snapshot, ringBuffer) 3511 return out, metadata, &smithy.DeserializationError{ 3512 Err: fmt.Errorf("failed to decode response body, %w", err), 3513 Snapshot: snapshot.Bytes(), 3514 } 3515 } 3516 3517 return out, metadata, err 3518} 3519 3520func awsRestxml_deserializeOpErrorGetAccountLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3521 var errorBuffer bytes.Buffer 3522 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3523 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3524 } 3525 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3526 3527 errorCode := "UnknownError" 3528 errorMessage := errorCode 3529 3530 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3531 if err != nil { 3532 return err 3533 } 3534 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3535 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3536 } 3537 if len(errorComponents.Code) != 0 { 3538 errorCode = errorComponents.Code 3539 } 3540 if len(errorComponents.Message) != 0 { 3541 errorMessage = errorComponents.Message 3542 } 3543 errorBody.Seek(0, io.SeekStart) 3544 switch { 3545 case strings.EqualFold("InvalidInput", errorCode): 3546 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3547 3548 default: 3549 genericError := &smithy.GenericAPIError{ 3550 Code: errorCode, 3551 Message: errorMessage, 3552 } 3553 return genericError 3554 3555 } 3556} 3557 3558func awsRestxml_deserializeOpDocumentGetAccountLimitOutput(v **GetAccountLimitOutput, decoder smithyxml.NodeDecoder) error { 3559 if v == nil { 3560 return fmt.Errorf("unexpected nil of type %T", v) 3561 } 3562 var sv *GetAccountLimitOutput 3563 if *v == nil { 3564 sv = &GetAccountLimitOutput{} 3565 } else { 3566 sv = *v 3567 } 3568 3569 for { 3570 t, done, err := decoder.Token() 3571 if err != nil { 3572 return err 3573 } 3574 if done { 3575 break 3576 } 3577 originalDecoder := decoder 3578 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3579 switch { 3580 case strings.EqualFold("Count", t.Name.Local): 3581 val, err := decoder.Value() 3582 if err != nil { 3583 return err 3584 } 3585 if val == nil { 3586 break 3587 } 3588 { 3589 xtv := string(val) 3590 i64, err := strconv.ParseInt(xtv, 10, 64) 3591 if err != nil { 3592 return err 3593 } 3594 sv.Count = i64 3595 } 3596 3597 case strings.EqualFold("Limit", t.Name.Local): 3598 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3599 if err := awsRestxml_deserializeDocumentAccountLimit(&sv.Limit, nodeDecoder); err != nil { 3600 return err 3601 } 3602 3603 default: 3604 // Do nothing and ignore the unexpected tag element 3605 err = decoder.Decoder.Skip() 3606 if err != nil { 3607 return err 3608 } 3609 3610 } 3611 decoder = originalDecoder 3612 } 3613 *v = sv 3614 return nil 3615} 3616 3617type awsRestxml_deserializeOpGetChange struct { 3618} 3619 3620func (*awsRestxml_deserializeOpGetChange) ID() string { 3621 return "OperationDeserializer" 3622} 3623 3624func (m *awsRestxml_deserializeOpGetChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3625 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3626) { 3627 out, metadata, err = next.HandleDeserialize(ctx, in) 3628 if err != nil { 3629 return out, metadata, err 3630 } 3631 3632 response, ok := out.RawResponse.(*smithyhttp.Response) 3633 if !ok { 3634 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3635 } 3636 3637 if response.StatusCode < 200 || response.StatusCode >= 300 { 3638 return out, metadata, awsRestxml_deserializeOpErrorGetChange(response, &metadata) 3639 } 3640 output := &GetChangeOutput{} 3641 out.Result = output 3642 3643 var buff [1024]byte 3644 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3645 body := io.TeeReader(response.Body, ringBuffer) 3646 rootDecoder := xml.NewDecoder(body) 3647 t, err := smithyxml.FetchRootElement(rootDecoder) 3648 if err == io.EOF { 3649 return out, metadata, nil 3650 } 3651 if err != nil { 3652 var snapshot bytes.Buffer 3653 io.Copy(&snapshot, ringBuffer) 3654 return out, metadata, &smithy.DeserializationError{ 3655 Err: fmt.Errorf("failed to decode response body, %w", err), 3656 Snapshot: snapshot.Bytes(), 3657 } 3658 } 3659 3660 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3661 err = awsRestxml_deserializeOpDocumentGetChangeOutput(&output, decoder) 3662 if err != nil { 3663 var snapshot bytes.Buffer 3664 io.Copy(&snapshot, ringBuffer) 3665 return out, metadata, &smithy.DeserializationError{ 3666 Err: fmt.Errorf("failed to decode response body, %w", err), 3667 Snapshot: snapshot.Bytes(), 3668 } 3669 } 3670 3671 return out, metadata, err 3672} 3673 3674func awsRestxml_deserializeOpErrorGetChange(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3675 var errorBuffer bytes.Buffer 3676 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3677 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3678 } 3679 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3680 3681 errorCode := "UnknownError" 3682 errorMessage := errorCode 3683 3684 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3685 if err != nil { 3686 return err 3687 } 3688 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3689 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3690 } 3691 if len(errorComponents.Code) != 0 { 3692 errorCode = errorComponents.Code 3693 } 3694 if len(errorComponents.Message) != 0 { 3695 errorMessage = errorComponents.Message 3696 } 3697 errorBody.Seek(0, io.SeekStart) 3698 switch { 3699 case strings.EqualFold("InvalidInput", errorCode): 3700 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3701 3702 case strings.EqualFold("NoSuchChange", errorCode): 3703 return awsRestxml_deserializeErrorNoSuchChange(response, errorBody) 3704 3705 default: 3706 genericError := &smithy.GenericAPIError{ 3707 Code: errorCode, 3708 Message: errorMessage, 3709 } 3710 return genericError 3711 3712 } 3713} 3714 3715func awsRestxml_deserializeOpDocumentGetChangeOutput(v **GetChangeOutput, decoder smithyxml.NodeDecoder) error { 3716 if v == nil { 3717 return fmt.Errorf("unexpected nil of type %T", v) 3718 } 3719 var sv *GetChangeOutput 3720 if *v == nil { 3721 sv = &GetChangeOutput{} 3722 } else { 3723 sv = *v 3724 } 3725 3726 for { 3727 t, done, err := decoder.Token() 3728 if err != nil { 3729 return err 3730 } 3731 if done { 3732 break 3733 } 3734 originalDecoder := decoder 3735 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3736 switch { 3737 case strings.EqualFold("ChangeInfo", t.Name.Local): 3738 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3739 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3740 return err 3741 } 3742 3743 default: 3744 // Do nothing and ignore the unexpected tag element 3745 err = decoder.Decoder.Skip() 3746 if err != nil { 3747 return err 3748 } 3749 3750 } 3751 decoder = originalDecoder 3752 } 3753 *v = sv 3754 return nil 3755} 3756 3757type awsRestxml_deserializeOpGetCheckerIpRanges struct { 3758} 3759 3760func (*awsRestxml_deserializeOpGetCheckerIpRanges) ID() string { 3761 return "OperationDeserializer" 3762} 3763 3764func (m *awsRestxml_deserializeOpGetCheckerIpRanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3765 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3766) { 3767 out, metadata, err = next.HandleDeserialize(ctx, in) 3768 if err != nil { 3769 return out, metadata, err 3770 } 3771 3772 response, ok := out.RawResponse.(*smithyhttp.Response) 3773 if !ok { 3774 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3775 } 3776 3777 if response.StatusCode < 200 || response.StatusCode >= 300 { 3778 return out, metadata, awsRestxml_deserializeOpErrorGetCheckerIpRanges(response, &metadata) 3779 } 3780 output := &GetCheckerIpRangesOutput{} 3781 out.Result = output 3782 3783 var buff [1024]byte 3784 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3785 body := io.TeeReader(response.Body, ringBuffer) 3786 rootDecoder := xml.NewDecoder(body) 3787 t, err := smithyxml.FetchRootElement(rootDecoder) 3788 if err == io.EOF { 3789 return out, metadata, nil 3790 } 3791 if err != nil { 3792 var snapshot bytes.Buffer 3793 io.Copy(&snapshot, ringBuffer) 3794 return out, metadata, &smithy.DeserializationError{ 3795 Err: fmt.Errorf("failed to decode response body, %w", err), 3796 Snapshot: snapshot.Bytes(), 3797 } 3798 } 3799 3800 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3801 err = awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(&output, decoder) 3802 if err != nil { 3803 var snapshot bytes.Buffer 3804 io.Copy(&snapshot, ringBuffer) 3805 return out, metadata, &smithy.DeserializationError{ 3806 Err: fmt.Errorf("failed to decode response body, %w", err), 3807 Snapshot: snapshot.Bytes(), 3808 } 3809 } 3810 3811 return out, metadata, err 3812} 3813 3814func awsRestxml_deserializeOpErrorGetCheckerIpRanges(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3815 var errorBuffer bytes.Buffer 3816 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3817 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3818 } 3819 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3820 3821 errorCode := "UnknownError" 3822 errorMessage := errorCode 3823 3824 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3825 if err != nil { 3826 return err 3827 } 3828 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3829 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3830 } 3831 if len(errorComponents.Code) != 0 { 3832 errorCode = errorComponents.Code 3833 } 3834 if len(errorComponents.Message) != 0 { 3835 errorMessage = errorComponents.Message 3836 } 3837 errorBody.Seek(0, io.SeekStart) 3838 switch { 3839 default: 3840 genericError := &smithy.GenericAPIError{ 3841 Code: errorCode, 3842 Message: errorMessage, 3843 } 3844 return genericError 3845 3846 } 3847} 3848 3849func awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(v **GetCheckerIpRangesOutput, decoder smithyxml.NodeDecoder) error { 3850 if v == nil { 3851 return fmt.Errorf("unexpected nil of type %T", v) 3852 } 3853 var sv *GetCheckerIpRangesOutput 3854 if *v == nil { 3855 sv = &GetCheckerIpRangesOutput{} 3856 } else { 3857 sv = *v 3858 } 3859 3860 for { 3861 t, done, err := decoder.Token() 3862 if err != nil { 3863 return err 3864 } 3865 if done { 3866 break 3867 } 3868 originalDecoder := decoder 3869 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3870 switch { 3871 case strings.EqualFold("CheckerIpRanges", t.Name.Local): 3872 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3873 if err := awsRestxml_deserializeDocumentCheckerIpRanges(&sv.CheckerIpRanges, nodeDecoder); err != nil { 3874 return err 3875 } 3876 3877 default: 3878 // Do nothing and ignore the unexpected tag element 3879 err = decoder.Decoder.Skip() 3880 if err != nil { 3881 return err 3882 } 3883 3884 } 3885 decoder = originalDecoder 3886 } 3887 *v = sv 3888 return nil 3889} 3890 3891type awsRestxml_deserializeOpGetDNSSEC struct { 3892} 3893 3894func (*awsRestxml_deserializeOpGetDNSSEC) ID() string { 3895 return "OperationDeserializer" 3896} 3897 3898func (m *awsRestxml_deserializeOpGetDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3899 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3900) { 3901 out, metadata, err = next.HandleDeserialize(ctx, in) 3902 if err != nil { 3903 return out, metadata, err 3904 } 3905 3906 response, ok := out.RawResponse.(*smithyhttp.Response) 3907 if !ok { 3908 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3909 } 3910 3911 if response.StatusCode < 200 || response.StatusCode >= 300 { 3912 return out, metadata, awsRestxml_deserializeOpErrorGetDNSSEC(response, &metadata) 3913 } 3914 output := &GetDNSSECOutput{} 3915 out.Result = output 3916 3917 var buff [1024]byte 3918 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3919 body := io.TeeReader(response.Body, ringBuffer) 3920 rootDecoder := xml.NewDecoder(body) 3921 t, err := smithyxml.FetchRootElement(rootDecoder) 3922 if err == io.EOF { 3923 return out, metadata, nil 3924 } 3925 if err != nil { 3926 var snapshot bytes.Buffer 3927 io.Copy(&snapshot, ringBuffer) 3928 return out, metadata, &smithy.DeserializationError{ 3929 Err: fmt.Errorf("failed to decode response body, %w", err), 3930 Snapshot: snapshot.Bytes(), 3931 } 3932 } 3933 3934 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3935 err = awsRestxml_deserializeOpDocumentGetDNSSECOutput(&output, decoder) 3936 if err != nil { 3937 var snapshot bytes.Buffer 3938 io.Copy(&snapshot, ringBuffer) 3939 return out, metadata, &smithy.DeserializationError{ 3940 Err: fmt.Errorf("failed to decode response body, %w", err), 3941 Snapshot: snapshot.Bytes(), 3942 } 3943 } 3944 3945 return out, metadata, err 3946} 3947 3948func awsRestxml_deserializeOpErrorGetDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3949 var errorBuffer bytes.Buffer 3950 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3951 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3952 } 3953 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3954 3955 errorCode := "UnknownError" 3956 errorMessage := errorCode 3957 3958 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3959 if err != nil { 3960 return err 3961 } 3962 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3963 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3964 } 3965 if len(errorComponents.Code) != 0 { 3966 errorCode = errorComponents.Code 3967 } 3968 if len(errorComponents.Message) != 0 { 3969 errorMessage = errorComponents.Message 3970 } 3971 errorBody.Seek(0, io.SeekStart) 3972 switch { 3973 case strings.EqualFold("InvalidArgument", errorCode): 3974 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 3975 3976 case strings.EqualFold("NoSuchHostedZone", errorCode): 3977 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3978 3979 default: 3980 genericError := &smithy.GenericAPIError{ 3981 Code: errorCode, 3982 Message: errorMessage, 3983 } 3984 return genericError 3985 3986 } 3987} 3988 3989func awsRestxml_deserializeOpDocumentGetDNSSECOutput(v **GetDNSSECOutput, decoder smithyxml.NodeDecoder) error { 3990 if v == nil { 3991 return fmt.Errorf("unexpected nil of type %T", v) 3992 } 3993 var sv *GetDNSSECOutput 3994 if *v == nil { 3995 sv = &GetDNSSECOutput{} 3996 } else { 3997 sv = *v 3998 } 3999 4000 for { 4001 t, done, err := decoder.Token() 4002 if err != nil { 4003 return err 4004 } 4005 if done { 4006 break 4007 } 4008 originalDecoder := decoder 4009 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4010 switch { 4011 case strings.EqualFold("KeySigningKeys", t.Name.Local): 4012 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4013 if err := awsRestxml_deserializeDocumentKeySigningKeys(&sv.KeySigningKeys, nodeDecoder); err != nil { 4014 return err 4015 } 4016 4017 case strings.EqualFold("Status", t.Name.Local): 4018 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4019 if err := awsRestxml_deserializeDocumentDNSSECStatus(&sv.Status, nodeDecoder); err != nil { 4020 return err 4021 } 4022 4023 default: 4024 // Do nothing and ignore the unexpected tag element 4025 err = decoder.Decoder.Skip() 4026 if err != nil { 4027 return err 4028 } 4029 4030 } 4031 decoder = originalDecoder 4032 } 4033 *v = sv 4034 return nil 4035} 4036 4037type awsRestxml_deserializeOpGetGeoLocation struct { 4038} 4039 4040func (*awsRestxml_deserializeOpGetGeoLocation) ID() string { 4041 return "OperationDeserializer" 4042} 4043 4044func (m *awsRestxml_deserializeOpGetGeoLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4045 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4046) { 4047 out, metadata, err = next.HandleDeserialize(ctx, in) 4048 if err != nil { 4049 return out, metadata, err 4050 } 4051 4052 response, ok := out.RawResponse.(*smithyhttp.Response) 4053 if !ok { 4054 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4055 } 4056 4057 if response.StatusCode < 200 || response.StatusCode >= 300 { 4058 return out, metadata, awsRestxml_deserializeOpErrorGetGeoLocation(response, &metadata) 4059 } 4060 output := &GetGeoLocationOutput{} 4061 out.Result = output 4062 4063 var buff [1024]byte 4064 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4065 body := io.TeeReader(response.Body, ringBuffer) 4066 rootDecoder := xml.NewDecoder(body) 4067 t, err := smithyxml.FetchRootElement(rootDecoder) 4068 if err == io.EOF { 4069 return out, metadata, nil 4070 } 4071 if err != nil { 4072 var snapshot bytes.Buffer 4073 io.Copy(&snapshot, ringBuffer) 4074 return out, metadata, &smithy.DeserializationError{ 4075 Err: fmt.Errorf("failed to decode response body, %w", err), 4076 Snapshot: snapshot.Bytes(), 4077 } 4078 } 4079 4080 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4081 err = awsRestxml_deserializeOpDocumentGetGeoLocationOutput(&output, decoder) 4082 if err != nil { 4083 var snapshot bytes.Buffer 4084 io.Copy(&snapshot, ringBuffer) 4085 return out, metadata, &smithy.DeserializationError{ 4086 Err: fmt.Errorf("failed to decode response body, %w", err), 4087 Snapshot: snapshot.Bytes(), 4088 } 4089 } 4090 4091 return out, metadata, err 4092} 4093 4094func awsRestxml_deserializeOpErrorGetGeoLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4095 var errorBuffer bytes.Buffer 4096 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4097 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4098 } 4099 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4100 4101 errorCode := "UnknownError" 4102 errorMessage := errorCode 4103 4104 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4105 if err != nil { 4106 return err 4107 } 4108 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4109 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4110 } 4111 if len(errorComponents.Code) != 0 { 4112 errorCode = errorComponents.Code 4113 } 4114 if len(errorComponents.Message) != 0 { 4115 errorMessage = errorComponents.Message 4116 } 4117 errorBody.Seek(0, io.SeekStart) 4118 switch { 4119 case strings.EqualFold("InvalidInput", errorCode): 4120 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4121 4122 case strings.EqualFold("NoSuchGeoLocation", errorCode): 4123 return awsRestxml_deserializeErrorNoSuchGeoLocation(response, errorBody) 4124 4125 default: 4126 genericError := &smithy.GenericAPIError{ 4127 Code: errorCode, 4128 Message: errorMessage, 4129 } 4130 return genericError 4131 4132 } 4133} 4134 4135func awsRestxml_deserializeOpDocumentGetGeoLocationOutput(v **GetGeoLocationOutput, decoder smithyxml.NodeDecoder) error { 4136 if v == nil { 4137 return fmt.Errorf("unexpected nil of type %T", v) 4138 } 4139 var sv *GetGeoLocationOutput 4140 if *v == nil { 4141 sv = &GetGeoLocationOutput{} 4142 } else { 4143 sv = *v 4144 } 4145 4146 for { 4147 t, done, err := decoder.Token() 4148 if err != nil { 4149 return err 4150 } 4151 if done { 4152 break 4153 } 4154 originalDecoder := decoder 4155 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4156 switch { 4157 case strings.EqualFold("GeoLocationDetails", t.Name.Local): 4158 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4159 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&sv.GeoLocationDetails, nodeDecoder); err != nil { 4160 return err 4161 } 4162 4163 default: 4164 // Do nothing and ignore the unexpected tag element 4165 err = decoder.Decoder.Skip() 4166 if err != nil { 4167 return err 4168 } 4169 4170 } 4171 decoder = originalDecoder 4172 } 4173 *v = sv 4174 return nil 4175} 4176 4177type awsRestxml_deserializeOpGetHealthCheck struct { 4178} 4179 4180func (*awsRestxml_deserializeOpGetHealthCheck) ID() string { 4181 return "OperationDeserializer" 4182} 4183 4184func (m *awsRestxml_deserializeOpGetHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4185 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4186) { 4187 out, metadata, err = next.HandleDeserialize(ctx, in) 4188 if err != nil { 4189 return out, metadata, err 4190 } 4191 4192 response, ok := out.RawResponse.(*smithyhttp.Response) 4193 if !ok { 4194 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4195 } 4196 4197 if response.StatusCode < 200 || response.StatusCode >= 300 { 4198 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheck(response, &metadata) 4199 } 4200 output := &GetHealthCheckOutput{} 4201 out.Result = output 4202 4203 var buff [1024]byte 4204 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4205 body := io.TeeReader(response.Body, ringBuffer) 4206 rootDecoder := xml.NewDecoder(body) 4207 t, err := smithyxml.FetchRootElement(rootDecoder) 4208 if err == io.EOF { 4209 return out, metadata, nil 4210 } 4211 if err != nil { 4212 var snapshot bytes.Buffer 4213 io.Copy(&snapshot, ringBuffer) 4214 return out, metadata, &smithy.DeserializationError{ 4215 Err: fmt.Errorf("failed to decode response body, %w", err), 4216 Snapshot: snapshot.Bytes(), 4217 } 4218 } 4219 4220 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4221 err = awsRestxml_deserializeOpDocumentGetHealthCheckOutput(&output, decoder) 4222 if err != nil { 4223 var snapshot bytes.Buffer 4224 io.Copy(&snapshot, ringBuffer) 4225 return out, metadata, &smithy.DeserializationError{ 4226 Err: fmt.Errorf("failed to decode response body, %w", err), 4227 Snapshot: snapshot.Bytes(), 4228 } 4229 } 4230 4231 return out, metadata, err 4232} 4233 4234func awsRestxml_deserializeOpErrorGetHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4235 var errorBuffer bytes.Buffer 4236 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4237 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4238 } 4239 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4240 4241 errorCode := "UnknownError" 4242 errorMessage := errorCode 4243 4244 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4245 if err != nil { 4246 return err 4247 } 4248 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4249 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4250 } 4251 if len(errorComponents.Code) != 0 { 4252 errorCode = errorComponents.Code 4253 } 4254 if len(errorComponents.Message) != 0 { 4255 errorMessage = errorComponents.Message 4256 } 4257 errorBody.Seek(0, io.SeekStart) 4258 switch { 4259 case strings.EqualFold("IncompatibleVersion", errorCode): 4260 return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody) 4261 4262 case strings.EqualFold("InvalidInput", errorCode): 4263 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4264 4265 case strings.EqualFold("NoSuchHealthCheck", errorCode): 4266 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 4267 4268 default: 4269 genericError := &smithy.GenericAPIError{ 4270 Code: errorCode, 4271 Message: errorMessage, 4272 } 4273 return genericError 4274 4275 } 4276} 4277 4278func awsRestxml_deserializeOpDocumentGetHealthCheckOutput(v **GetHealthCheckOutput, decoder smithyxml.NodeDecoder) error { 4279 if v == nil { 4280 return fmt.Errorf("unexpected nil of type %T", v) 4281 } 4282 var sv *GetHealthCheckOutput 4283 if *v == nil { 4284 sv = &GetHealthCheckOutput{} 4285 } else { 4286 sv = *v 4287 } 4288 4289 for { 4290 t, done, err := decoder.Token() 4291 if err != nil { 4292 return err 4293 } 4294 if done { 4295 break 4296 } 4297 originalDecoder := decoder 4298 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4299 switch { 4300 case strings.EqualFold("HealthCheck", t.Name.Local): 4301 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4302 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil { 4303 return err 4304 } 4305 4306 default: 4307 // Do nothing and ignore the unexpected tag element 4308 err = decoder.Decoder.Skip() 4309 if err != nil { 4310 return err 4311 } 4312 4313 } 4314 decoder = originalDecoder 4315 } 4316 *v = sv 4317 return nil 4318} 4319 4320type awsRestxml_deserializeOpGetHealthCheckCount struct { 4321} 4322 4323func (*awsRestxml_deserializeOpGetHealthCheckCount) ID() string { 4324 return "OperationDeserializer" 4325} 4326 4327func (m *awsRestxml_deserializeOpGetHealthCheckCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4328 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4329) { 4330 out, metadata, err = next.HandleDeserialize(ctx, in) 4331 if err != nil { 4332 return out, metadata, err 4333 } 4334 4335 response, ok := out.RawResponse.(*smithyhttp.Response) 4336 if !ok { 4337 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4338 } 4339 4340 if response.StatusCode < 200 || response.StatusCode >= 300 { 4341 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckCount(response, &metadata) 4342 } 4343 output := &GetHealthCheckCountOutput{} 4344 out.Result = output 4345 4346 var buff [1024]byte 4347 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4348 body := io.TeeReader(response.Body, ringBuffer) 4349 rootDecoder := xml.NewDecoder(body) 4350 t, err := smithyxml.FetchRootElement(rootDecoder) 4351 if err == io.EOF { 4352 return out, metadata, nil 4353 } 4354 if err != nil { 4355 var snapshot bytes.Buffer 4356 io.Copy(&snapshot, ringBuffer) 4357 return out, metadata, &smithy.DeserializationError{ 4358 Err: fmt.Errorf("failed to decode response body, %w", err), 4359 Snapshot: snapshot.Bytes(), 4360 } 4361 } 4362 4363 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4364 err = awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(&output, decoder) 4365 if err != nil { 4366 var snapshot bytes.Buffer 4367 io.Copy(&snapshot, ringBuffer) 4368 return out, metadata, &smithy.DeserializationError{ 4369 Err: fmt.Errorf("failed to decode response body, %w", err), 4370 Snapshot: snapshot.Bytes(), 4371 } 4372 } 4373 4374 return out, metadata, err 4375} 4376 4377func awsRestxml_deserializeOpErrorGetHealthCheckCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4378 var errorBuffer bytes.Buffer 4379 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4380 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4381 } 4382 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4383 4384 errorCode := "UnknownError" 4385 errorMessage := errorCode 4386 4387 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4388 if err != nil { 4389 return err 4390 } 4391 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4392 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4393 } 4394 if len(errorComponents.Code) != 0 { 4395 errorCode = errorComponents.Code 4396 } 4397 if len(errorComponents.Message) != 0 { 4398 errorMessage = errorComponents.Message 4399 } 4400 errorBody.Seek(0, io.SeekStart) 4401 switch { 4402 default: 4403 genericError := &smithy.GenericAPIError{ 4404 Code: errorCode, 4405 Message: errorMessage, 4406 } 4407 return genericError 4408 4409 } 4410} 4411 4412func awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(v **GetHealthCheckCountOutput, decoder smithyxml.NodeDecoder) error { 4413 if v == nil { 4414 return fmt.Errorf("unexpected nil of type %T", v) 4415 } 4416 var sv *GetHealthCheckCountOutput 4417 if *v == nil { 4418 sv = &GetHealthCheckCountOutput{} 4419 } else { 4420 sv = *v 4421 } 4422 4423 for { 4424 t, done, err := decoder.Token() 4425 if err != nil { 4426 return err 4427 } 4428 if done { 4429 break 4430 } 4431 originalDecoder := decoder 4432 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4433 switch { 4434 case strings.EqualFold("HealthCheckCount", t.Name.Local): 4435 val, err := decoder.Value() 4436 if err != nil { 4437 return err 4438 } 4439 if val == nil { 4440 break 4441 } 4442 { 4443 xtv := string(val) 4444 i64, err := strconv.ParseInt(xtv, 10, 64) 4445 if err != nil { 4446 return err 4447 } 4448 sv.HealthCheckCount = ptr.Int64(i64) 4449 } 4450 4451 default: 4452 // Do nothing and ignore the unexpected tag element 4453 err = decoder.Decoder.Skip() 4454 if err != nil { 4455 return err 4456 } 4457 4458 } 4459 decoder = originalDecoder 4460 } 4461 *v = sv 4462 return nil 4463} 4464 4465type awsRestxml_deserializeOpGetHealthCheckLastFailureReason struct { 4466} 4467 4468func (*awsRestxml_deserializeOpGetHealthCheckLastFailureReason) ID() string { 4469 return "OperationDeserializer" 4470} 4471 4472func (m *awsRestxml_deserializeOpGetHealthCheckLastFailureReason) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4473 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4474) { 4475 out, metadata, err = next.HandleDeserialize(ctx, in) 4476 if err != nil { 4477 return out, metadata, err 4478 } 4479 4480 response, ok := out.RawResponse.(*smithyhttp.Response) 4481 if !ok { 4482 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4483 } 4484 4485 if response.StatusCode < 200 || response.StatusCode >= 300 { 4486 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response, &metadata) 4487 } 4488 output := &GetHealthCheckLastFailureReasonOutput{} 4489 out.Result = output 4490 4491 var buff [1024]byte 4492 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4493 body := io.TeeReader(response.Body, ringBuffer) 4494 rootDecoder := xml.NewDecoder(body) 4495 t, err := smithyxml.FetchRootElement(rootDecoder) 4496 if err == io.EOF { 4497 return out, metadata, nil 4498 } 4499 if err != nil { 4500 var snapshot bytes.Buffer 4501 io.Copy(&snapshot, ringBuffer) 4502 return out, metadata, &smithy.DeserializationError{ 4503 Err: fmt.Errorf("failed to decode response body, %w", err), 4504 Snapshot: snapshot.Bytes(), 4505 } 4506 } 4507 4508 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4509 err = awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(&output, decoder) 4510 if err != nil { 4511 var snapshot bytes.Buffer 4512 io.Copy(&snapshot, ringBuffer) 4513 return out, metadata, &smithy.DeserializationError{ 4514 Err: fmt.Errorf("failed to decode response body, %w", err), 4515 Snapshot: snapshot.Bytes(), 4516 } 4517 } 4518 4519 return out, metadata, err 4520} 4521 4522func awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4523 var errorBuffer bytes.Buffer 4524 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4525 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4526 } 4527 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4528 4529 errorCode := "UnknownError" 4530 errorMessage := errorCode 4531 4532 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4533 if err != nil { 4534 return err 4535 } 4536 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4537 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4538 } 4539 if len(errorComponents.Code) != 0 { 4540 errorCode = errorComponents.Code 4541 } 4542 if len(errorComponents.Message) != 0 { 4543 errorMessage = errorComponents.Message 4544 } 4545 errorBody.Seek(0, io.SeekStart) 4546 switch { 4547 case strings.EqualFold("InvalidInput", errorCode): 4548 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4549 4550 case strings.EqualFold("NoSuchHealthCheck", errorCode): 4551 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 4552 4553 default: 4554 genericError := &smithy.GenericAPIError{ 4555 Code: errorCode, 4556 Message: errorMessage, 4557 } 4558 return genericError 4559 4560 } 4561} 4562 4563func awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(v **GetHealthCheckLastFailureReasonOutput, decoder smithyxml.NodeDecoder) error { 4564 if v == nil { 4565 return fmt.Errorf("unexpected nil of type %T", v) 4566 } 4567 var sv *GetHealthCheckLastFailureReasonOutput 4568 if *v == nil { 4569 sv = &GetHealthCheckLastFailureReasonOutput{} 4570 } else { 4571 sv = *v 4572 } 4573 4574 for { 4575 t, done, err := decoder.Token() 4576 if err != nil { 4577 return err 4578 } 4579 if done { 4580 break 4581 } 4582 originalDecoder := decoder 4583 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4584 switch { 4585 case strings.EqualFold("HealthCheckObservations", t.Name.Local): 4586 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4587 if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil { 4588 return err 4589 } 4590 4591 default: 4592 // Do nothing and ignore the unexpected tag element 4593 err = decoder.Decoder.Skip() 4594 if err != nil { 4595 return err 4596 } 4597 4598 } 4599 decoder = originalDecoder 4600 } 4601 *v = sv 4602 return nil 4603} 4604 4605type awsRestxml_deserializeOpGetHealthCheckStatus struct { 4606} 4607 4608func (*awsRestxml_deserializeOpGetHealthCheckStatus) ID() string { 4609 return "OperationDeserializer" 4610} 4611 4612func (m *awsRestxml_deserializeOpGetHealthCheckStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4613 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4614) { 4615 out, metadata, err = next.HandleDeserialize(ctx, in) 4616 if err != nil { 4617 return out, metadata, err 4618 } 4619 4620 response, ok := out.RawResponse.(*smithyhttp.Response) 4621 if !ok { 4622 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4623 } 4624 4625 if response.StatusCode < 200 || response.StatusCode >= 300 { 4626 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckStatus(response, &metadata) 4627 } 4628 output := &GetHealthCheckStatusOutput{} 4629 out.Result = output 4630 4631 var buff [1024]byte 4632 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4633 body := io.TeeReader(response.Body, ringBuffer) 4634 rootDecoder := xml.NewDecoder(body) 4635 t, err := smithyxml.FetchRootElement(rootDecoder) 4636 if err == io.EOF { 4637 return out, metadata, nil 4638 } 4639 if err != nil { 4640 var snapshot bytes.Buffer 4641 io.Copy(&snapshot, ringBuffer) 4642 return out, metadata, &smithy.DeserializationError{ 4643 Err: fmt.Errorf("failed to decode response body, %w", err), 4644 Snapshot: snapshot.Bytes(), 4645 } 4646 } 4647 4648 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4649 err = awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(&output, decoder) 4650 if err != nil { 4651 var snapshot bytes.Buffer 4652 io.Copy(&snapshot, ringBuffer) 4653 return out, metadata, &smithy.DeserializationError{ 4654 Err: fmt.Errorf("failed to decode response body, %w", err), 4655 Snapshot: snapshot.Bytes(), 4656 } 4657 } 4658 4659 return out, metadata, err 4660} 4661 4662func awsRestxml_deserializeOpErrorGetHealthCheckStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4663 var errorBuffer bytes.Buffer 4664 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4665 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4666 } 4667 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4668 4669 errorCode := "UnknownError" 4670 errorMessage := errorCode 4671 4672 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4673 if err != nil { 4674 return err 4675 } 4676 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4677 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4678 } 4679 if len(errorComponents.Code) != 0 { 4680 errorCode = errorComponents.Code 4681 } 4682 if len(errorComponents.Message) != 0 { 4683 errorMessage = errorComponents.Message 4684 } 4685 errorBody.Seek(0, io.SeekStart) 4686 switch { 4687 case strings.EqualFold("InvalidInput", errorCode): 4688 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4689 4690 case strings.EqualFold("NoSuchHealthCheck", errorCode): 4691 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 4692 4693 default: 4694 genericError := &smithy.GenericAPIError{ 4695 Code: errorCode, 4696 Message: errorMessage, 4697 } 4698 return genericError 4699 4700 } 4701} 4702 4703func awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(v **GetHealthCheckStatusOutput, decoder smithyxml.NodeDecoder) error { 4704 if v == nil { 4705 return fmt.Errorf("unexpected nil of type %T", v) 4706 } 4707 var sv *GetHealthCheckStatusOutput 4708 if *v == nil { 4709 sv = &GetHealthCheckStatusOutput{} 4710 } else { 4711 sv = *v 4712 } 4713 4714 for { 4715 t, done, err := decoder.Token() 4716 if err != nil { 4717 return err 4718 } 4719 if done { 4720 break 4721 } 4722 originalDecoder := decoder 4723 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4724 switch { 4725 case strings.EqualFold("HealthCheckObservations", t.Name.Local): 4726 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4727 if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil { 4728 return err 4729 } 4730 4731 default: 4732 // Do nothing and ignore the unexpected tag element 4733 err = decoder.Decoder.Skip() 4734 if err != nil { 4735 return err 4736 } 4737 4738 } 4739 decoder = originalDecoder 4740 } 4741 *v = sv 4742 return nil 4743} 4744 4745type awsRestxml_deserializeOpGetHostedZone struct { 4746} 4747 4748func (*awsRestxml_deserializeOpGetHostedZone) ID() string { 4749 return "OperationDeserializer" 4750} 4751 4752func (m *awsRestxml_deserializeOpGetHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4753 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4754) { 4755 out, metadata, err = next.HandleDeserialize(ctx, in) 4756 if err != nil { 4757 return out, metadata, err 4758 } 4759 4760 response, ok := out.RawResponse.(*smithyhttp.Response) 4761 if !ok { 4762 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4763 } 4764 4765 if response.StatusCode < 200 || response.StatusCode >= 300 { 4766 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZone(response, &metadata) 4767 } 4768 output := &GetHostedZoneOutput{} 4769 out.Result = output 4770 4771 var buff [1024]byte 4772 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4773 body := io.TeeReader(response.Body, ringBuffer) 4774 rootDecoder := xml.NewDecoder(body) 4775 t, err := smithyxml.FetchRootElement(rootDecoder) 4776 if err == io.EOF { 4777 return out, metadata, nil 4778 } 4779 if err != nil { 4780 var snapshot bytes.Buffer 4781 io.Copy(&snapshot, ringBuffer) 4782 return out, metadata, &smithy.DeserializationError{ 4783 Err: fmt.Errorf("failed to decode response body, %w", err), 4784 Snapshot: snapshot.Bytes(), 4785 } 4786 } 4787 4788 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4789 err = awsRestxml_deserializeOpDocumentGetHostedZoneOutput(&output, decoder) 4790 if err != nil { 4791 var snapshot bytes.Buffer 4792 io.Copy(&snapshot, ringBuffer) 4793 return out, metadata, &smithy.DeserializationError{ 4794 Err: fmt.Errorf("failed to decode response body, %w", err), 4795 Snapshot: snapshot.Bytes(), 4796 } 4797 } 4798 4799 return out, metadata, err 4800} 4801 4802func awsRestxml_deserializeOpErrorGetHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4803 var errorBuffer bytes.Buffer 4804 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4805 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4806 } 4807 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4808 4809 errorCode := "UnknownError" 4810 errorMessage := errorCode 4811 4812 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4813 if err != nil { 4814 return err 4815 } 4816 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4817 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4818 } 4819 if len(errorComponents.Code) != 0 { 4820 errorCode = errorComponents.Code 4821 } 4822 if len(errorComponents.Message) != 0 { 4823 errorMessage = errorComponents.Message 4824 } 4825 errorBody.Seek(0, io.SeekStart) 4826 switch { 4827 case strings.EqualFold("InvalidInput", errorCode): 4828 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4829 4830 case strings.EqualFold("NoSuchHostedZone", errorCode): 4831 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 4832 4833 default: 4834 genericError := &smithy.GenericAPIError{ 4835 Code: errorCode, 4836 Message: errorMessage, 4837 } 4838 return genericError 4839 4840 } 4841} 4842 4843func awsRestxml_deserializeOpDocumentGetHostedZoneOutput(v **GetHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 4844 if v == nil { 4845 return fmt.Errorf("unexpected nil of type %T", v) 4846 } 4847 var sv *GetHostedZoneOutput 4848 if *v == nil { 4849 sv = &GetHostedZoneOutput{} 4850 } else { 4851 sv = *v 4852 } 4853 4854 for { 4855 t, done, err := decoder.Token() 4856 if err != nil { 4857 return err 4858 } 4859 if done { 4860 break 4861 } 4862 originalDecoder := decoder 4863 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4864 switch { 4865 case strings.EqualFold("DelegationSet", t.Name.Local): 4866 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4867 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 4868 return err 4869 } 4870 4871 case strings.EqualFold("HostedZone", t.Name.Local): 4872 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4873 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil { 4874 return err 4875 } 4876 4877 case strings.EqualFold("VPCs", t.Name.Local): 4878 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4879 if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil { 4880 return err 4881 } 4882 4883 default: 4884 // Do nothing and ignore the unexpected tag element 4885 err = decoder.Decoder.Skip() 4886 if err != nil { 4887 return err 4888 } 4889 4890 } 4891 decoder = originalDecoder 4892 } 4893 *v = sv 4894 return nil 4895} 4896 4897type awsRestxml_deserializeOpGetHostedZoneCount struct { 4898} 4899 4900func (*awsRestxml_deserializeOpGetHostedZoneCount) ID() string { 4901 return "OperationDeserializer" 4902} 4903 4904func (m *awsRestxml_deserializeOpGetHostedZoneCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4905 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4906) { 4907 out, metadata, err = next.HandleDeserialize(ctx, in) 4908 if err != nil { 4909 return out, metadata, err 4910 } 4911 4912 response, ok := out.RawResponse.(*smithyhttp.Response) 4913 if !ok { 4914 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4915 } 4916 4917 if response.StatusCode < 200 || response.StatusCode >= 300 { 4918 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneCount(response, &metadata) 4919 } 4920 output := &GetHostedZoneCountOutput{} 4921 out.Result = output 4922 4923 var buff [1024]byte 4924 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4925 body := io.TeeReader(response.Body, ringBuffer) 4926 rootDecoder := xml.NewDecoder(body) 4927 t, err := smithyxml.FetchRootElement(rootDecoder) 4928 if err == io.EOF { 4929 return out, metadata, nil 4930 } 4931 if err != nil { 4932 var snapshot bytes.Buffer 4933 io.Copy(&snapshot, ringBuffer) 4934 return out, metadata, &smithy.DeserializationError{ 4935 Err: fmt.Errorf("failed to decode response body, %w", err), 4936 Snapshot: snapshot.Bytes(), 4937 } 4938 } 4939 4940 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4941 err = awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(&output, decoder) 4942 if err != nil { 4943 var snapshot bytes.Buffer 4944 io.Copy(&snapshot, ringBuffer) 4945 return out, metadata, &smithy.DeserializationError{ 4946 Err: fmt.Errorf("failed to decode response body, %w", err), 4947 Snapshot: snapshot.Bytes(), 4948 } 4949 } 4950 4951 return out, metadata, err 4952} 4953 4954func awsRestxml_deserializeOpErrorGetHostedZoneCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4955 var errorBuffer bytes.Buffer 4956 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4957 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4958 } 4959 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4960 4961 errorCode := "UnknownError" 4962 errorMessage := errorCode 4963 4964 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4965 if err != nil { 4966 return err 4967 } 4968 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4969 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4970 } 4971 if len(errorComponents.Code) != 0 { 4972 errorCode = errorComponents.Code 4973 } 4974 if len(errorComponents.Message) != 0 { 4975 errorMessage = errorComponents.Message 4976 } 4977 errorBody.Seek(0, io.SeekStart) 4978 switch { 4979 case strings.EqualFold("InvalidInput", errorCode): 4980 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4981 4982 default: 4983 genericError := &smithy.GenericAPIError{ 4984 Code: errorCode, 4985 Message: errorMessage, 4986 } 4987 return genericError 4988 4989 } 4990} 4991 4992func awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(v **GetHostedZoneCountOutput, decoder smithyxml.NodeDecoder) error { 4993 if v == nil { 4994 return fmt.Errorf("unexpected nil of type %T", v) 4995 } 4996 var sv *GetHostedZoneCountOutput 4997 if *v == nil { 4998 sv = &GetHostedZoneCountOutput{} 4999 } else { 5000 sv = *v 5001 } 5002 5003 for { 5004 t, done, err := decoder.Token() 5005 if err != nil { 5006 return err 5007 } 5008 if done { 5009 break 5010 } 5011 originalDecoder := decoder 5012 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5013 switch { 5014 case strings.EqualFold("HostedZoneCount", t.Name.Local): 5015 val, err := decoder.Value() 5016 if err != nil { 5017 return err 5018 } 5019 if val == nil { 5020 break 5021 } 5022 { 5023 xtv := string(val) 5024 i64, err := strconv.ParseInt(xtv, 10, 64) 5025 if err != nil { 5026 return err 5027 } 5028 sv.HostedZoneCount = ptr.Int64(i64) 5029 } 5030 5031 default: 5032 // Do nothing and ignore the unexpected tag element 5033 err = decoder.Decoder.Skip() 5034 if err != nil { 5035 return err 5036 } 5037 5038 } 5039 decoder = originalDecoder 5040 } 5041 *v = sv 5042 return nil 5043} 5044 5045type awsRestxml_deserializeOpGetHostedZoneLimit struct { 5046} 5047 5048func (*awsRestxml_deserializeOpGetHostedZoneLimit) ID() string { 5049 return "OperationDeserializer" 5050} 5051 5052func (m *awsRestxml_deserializeOpGetHostedZoneLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5053 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5054) { 5055 out, metadata, err = next.HandleDeserialize(ctx, in) 5056 if err != nil { 5057 return out, metadata, err 5058 } 5059 5060 response, ok := out.RawResponse.(*smithyhttp.Response) 5061 if !ok { 5062 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5063 } 5064 5065 if response.StatusCode < 200 || response.StatusCode >= 300 { 5066 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneLimit(response, &metadata) 5067 } 5068 output := &GetHostedZoneLimitOutput{} 5069 out.Result = output 5070 5071 var buff [1024]byte 5072 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5073 body := io.TeeReader(response.Body, ringBuffer) 5074 rootDecoder := xml.NewDecoder(body) 5075 t, err := smithyxml.FetchRootElement(rootDecoder) 5076 if err == io.EOF { 5077 return out, metadata, nil 5078 } 5079 if err != nil { 5080 var snapshot bytes.Buffer 5081 io.Copy(&snapshot, ringBuffer) 5082 return out, metadata, &smithy.DeserializationError{ 5083 Err: fmt.Errorf("failed to decode response body, %w", err), 5084 Snapshot: snapshot.Bytes(), 5085 } 5086 } 5087 5088 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5089 err = awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(&output, decoder) 5090 if err != nil { 5091 var snapshot bytes.Buffer 5092 io.Copy(&snapshot, ringBuffer) 5093 return out, metadata, &smithy.DeserializationError{ 5094 Err: fmt.Errorf("failed to decode response body, %w", err), 5095 Snapshot: snapshot.Bytes(), 5096 } 5097 } 5098 5099 return out, metadata, err 5100} 5101 5102func awsRestxml_deserializeOpErrorGetHostedZoneLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5103 var errorBuffer bytes.Buffer 5104 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5105 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5106 } 5107 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5108 5109 errorCode := "UnknownError" 5110 errorMessage := errorCode 5111 5112 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5113 if err != nil { 5114 return err 5115 } 5116 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5117 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5118 } 5119 if len(errorComponents.Code) != 0 { 5120 errorCode = errorComponents.Code 5121 } 5122 if len(errorComponents.Message) != 0 { 5123 errorMessage = errorComponents.Message 5124 } 5125 errorBody.Seek(0, io.SeekStart) 5126 switch { 5127 case strings.EqualFold("HostedZoneNotPrivate", errorCode): 5128 return awsRestxml_deserializeErrorHostedZoneNotPrivate(response, errorBody) 5129 5130 case strings.EqualFold("InvalidInput", errorCode): 5131 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5132 5133 case strings.EqualFold("NoSuchHostedZone", errorCode): 5134 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 5135 5136 default: 5137 genericError := &smithy.GenericAPIError{ 5138 Code: errorCode, 5139 Message: errorMessage, 5140 } 5141 return genericError 5142 5143 } 5144} 5145 5146func awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(v **GetHostedZoneLimitOutput, decoder smithyxml.NodeDecoder) error { 5147 if v == nil { 5148 return fmt.Errorf("unexpected nil of type %T", v) 5149 } 5150 var sv *GetHostedZoneLimitOutput 5151 if *v == nil { 5152 sv = &GetHostedZoneLimitOutput{} 5153 } else { 5154 sv = *v 5155 } 5156 5157 for { 5158 t, done, err := decoder.Token() 5159 if err != nil { 5160 return err 5161 } 5162 if done { 5163 break 5164 } 5165 originalDecoder := decoder 5166 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5167 switch { 5168 case strings.EqualFold("Count", t.Name.Local): 5169 val, err := decoder.Value() 5170 if err != nil { 5171 return err 5172 } 5173 if val == nil { 5174 break 5175 } 5176 { 5177 xtv := string(val) 5178 i64, err := strconv.ParseInt(xtv, 10, 64) 5179 if err != nil { 5180 return err 5181 } 5182 sv.Count = i64 5183 } 5184 5185 case strings.EqualFold("Limit", t.Name.Local): 5186 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5187 if err := awsRestxml_deserializeDocumentHostedZoneLimit(&sv.Limit, nodeDecoder); err != nil { 5188 return err 5189 } 5190 5191 default: 5192 // Do nothing and ignore the unexpected tag element 5193 err = decoder.Decoder.Skip() 5194 if err != nil { 5195 return err 5196 } 5197 5198 } 5199 decoder = originalDecoder 5200 } 5201 *v = sv 5202 return nil 5203} 5204 5205type awsRestxml_deserializeOpGetQueryLoggingConfig struct { 5206} 5207 5208func (*awsRestxml_deserializeOpGetQueryLoggingConfig) ID() string { 5209 return "OperationDeserializer" 5210} 5211 5212func (m *awsRestxml_deserializeOpGetQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5213 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5214) { 5215 out, metadata, err = next.HandleDeserialize(ctx, in) 5216 if err != nil { 5217 return out, metadata, err 5218 } 5219 5220 response, ok := out.RawResponse.(*smithyhttp.Response) 5221 if !ok { 5222 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5223 } 5224 5225 if response.StatusCode < 200 || response.StatusCode >= 300 { 5226 return out, metadata, awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response, &metadata) 5227 } 5228 output := &GetQueryLoggingConfigOutput{} 5229 out.Result = output 5230 5231 var buff [1024]byte 5232 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5233 body := io.TeeReader(response.Body, ringBuffer) 5234 rootDecoder := xml.NewDecoder(body) 5235 t, err := smithyxml.FetchRootElement(rootDecoder) 5236 if err == io.EOF { 5237 return out, metadata, nil 5238 } 5239 if err != nil { 5240 var snapshot bytes.Buffer 5241 io.Copy(&snapshot, ringBuffer) 5242 return out, metadata, &smithy.DeserializationError{ 5243 Err: fmt.Errorf("failed to decode response body, %w", err), 5244 Snapshot: snapshot.Bytes(), 5245 } 5246 } 5247 5248 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5249 err = awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(&output, decoder) 5250 if err != nil { 5251 var snapshot bytes.Buffer 5252 io.Copy(&snapshot, ringBuffer) 5253 return out, metadata, &smithy.DeserializationError{ 5254 Err: fmt.Errorf("failed to decode response body, %w", err), 5255 Snapshot: snapshot.Bytes(), 5256 } 5257 } 5258 5259 return out, metadata, err 5260} 5261 5262func awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5263 var errorBuffer bytes.Buffer 5264 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5265 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5266 } 5267 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5268 5269 errorCode := "UnknownError" 5270 errorMessage := errorCode 5271 5272 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5273 if err != nil { 5274 return err 5275 } 5276 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5277 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5278 } 5279 if len(errorComponents.Code) != 0 { 5280 errorCode = errorComponents.Code 5281 } 5282 if len(errorComponents.Message) != 0 { 5283 errorMessage = errorComponents.Message 5284 } 5285 errorBody.Seek(0, io.SeekStart) 5286 switch { 5287 case strings.EqualFold("InvalidInput", errorCode): 5288 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5289 5290 case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode): 5291 return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody) 5292 5293 default: 5294 genericError := &smithy.GenericAPIError{ 5295 Code: errorCode, 5296 Message: errorMessage, 5297 } 5298 return genericError 5299 5300 } 5301} 5302 5303func awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(v **GetQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error { 5304 if v == nil { 5305 return fmt.Errorf("unexpected nil of type %T", v) 5306 } 5307 var sv *GetQueryLoggingConfigOutput 5308 if *v == nil { 5309 sv = &GetQueryLoggingConfigOutput{} 5310 } else { 5311 sv = *v 5312 } 5313 5314 for { 5315 t, done, err := decoder.Token() 5316 if err != nil { 5317 return err 5318 } 5319 if done { 5320 break 5321 } 5322 originalDecoder := decoder 5323 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5324 switch { 5325 case strings.EqualFold("QueryLoggingConfig", t.Name.Local): 5326 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5327 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil { 5328 return err 5329 } 5330 5331 default: 5332 // Do nothing and ignore the unexpected tag element 5333 err = decoder.Decoder.Skip() 5334 if err != nil { 5335 return err 5336 } 5337 5338 } 5339 decoder = originalDecoder 5340 } 5341 *v = sv 5342 return nil 5343} 5344 5345type awsRestxml_deserializeOpGetReusableDelegationSet struct { 5346} 5347 5348func (*awsRestxml_deserializeOpGetReusableDelegationSet) ID() string { 5349 return "OperationDeserializer" 5350} 5351 5352func (m *awsRestxml_deserializeOpGetReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5353 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5354) { 5355 out, metadata, err = next.HandleDeserialize(ctx, in) 5356 if err != nil { 5357 return out, metadata, err 5358 } 5359 5360 response, ok := out.RawResponse.(*smithyhttp.Response) 5361 if !ok { 5362 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5363 } 5364 5365 if response.StatusCode < 200 || response.StatusCode >= 300 { 5366 return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSet(response, &metadata) 5367 } 5368 output := &GetReusableDelegationSetOutput{} 5369 out.Result = output 5370 5371 var buff [1024]byte 5372 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5373 body := io.TeeReader(response.Body, ringBuffer) 5374 rootDecoder := xml.NewDecoder(body) 5375 t, err := smithyxml.FetchRootElement(rootDecoder) 5376 if err == io.EOF { 5377 return out, metadata, nil 5378 } 5379 if err != nil { 5380 var snapshot bytes.Buffer 5381 io.Copy(&snapshot, ringBuffer) 5382 return out, metadata, &smithy.DeserializationError{ 5383 Err: fmt.Errorf("failed to decode response body, %w", err), 5384 Snapshot: snapshot.Bytes(), 5385 } 5386 } 5387 5388 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5389 err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(&output, decoder) 5390 if err != nil { 5391 var snapshot bytes.Buffer 5392 io.Copy(&snapshot, ringBuffer) 5393 return out, metadata, &smithy.DeserializationError{ 5394 Err: fmt.Errorf("failed to decode response body, %w", err), 5395 Snapshot: snapshot.Bytes(), 5396 } 5397 } 5398 5399 return out, metadata, err 5400} 5401 5402func awsRestxml_deserializeOpErrorGetReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5403 var errorBuffer bytes.Buffer 5404 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5405 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5406 } 5407 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5408 5409 errorCode := "UnknownError" 5410 errorMessage := errorCode 5411 5412 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5413 if err != nil { 5414 return err 5415 } 5416 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5417 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5418 } 5419 if len(errorComponents.Code) != 0 { 5420 errorCode = errorComponents.Code 5421 } 5422 if len(errorComponents.Message) != 0 { 5423 errorMessage = errorComponents.Message 5424 } 5425 errorBody.Seek(0, io.SeekStart) 5426 switch { 5427 case strings.EqualFold("DelegationSetNotReusable", errorCode): 5428 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 5429 5430 case strings.EqualFold("InvalidInput", errorCode): 5431 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5432 5433 case strings.EqualFold("NoSuchDelegationSet", errorCode): 5434 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 5435 5436 default: 5437 genericError := &smithy.GenericAPIError{ 5438 Code: errorCode, 5439 Message: errorMessage, 5440 } 5441 return genericError 5442 5443 } 5444} 5445 5446func awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(v **GetReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error { 5447 if v == nil { 5448 return fmt.Errorf("unexpected nil of type %T", v) 5449 } 5450 var sv *GetReusableDelegationSetOutput 5451 if *v == nil { 5452 sv = &GetReusableDelegationSetOutput{} 5453 } else { 5454 sv = *v 5455 } 5456 5457 for { 5458 t, done, err := decoder.Token() 5459 if err != nil { 5460 return err 5461 } 5462 if done { 5463 break 5464 } 5465 originalDecoder := decoder 5466 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5467 switch { 5468 case strings.EqualFold("DelegationSet", t.Name.Local): 5469 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5470 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 5471 return err 5472 } 5473 5474 default: 5475 // Do nothing and ignore the unexpected tag element 5476 err = decoder.Decoder.Skip() 5477 if err != nil { 5478 return err 5479 } 5480 5481 } 5482 decoder = originalDecoder 5483 } 5484 *v = sv 5485 return nil 5486} 5487 5488type awsRestxml_deserializeOpGetReusableDelegationSetLimit struct { 5489} 5490 5491func (*awsRestxml_deserializeOpGetReusableDelegationSetLimit) ID() string { 5492 return "OperationDeserializer" 5493} 5494 5495func (m *awsRestxml_deserializeOpGetReusableDelegationSetLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5496 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5497) { 5498 out, metadata, err = next.HandleDeserialize(ctx, in) 5499 if err != nil { 5500 return out, metadata, err 5501 } 5502 5503 response, ok := out.RawResponse.(*smithyhttp.Response) 5504 if !ok { 5505 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5506 } 5507 5508 if response.StatusCode < 200 || response.StatusCode >= 300 { 5509 return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response, &metadata) 5510 } 5511 output := &GetReusableDelegationSetLimitOutput{} 5512 out.Result = output 5513 5514 var buff [1024]byte 5515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5516 body := io.TeeReader(response.Body, ringBuffer) 5517 rootDecoder := xml.NewDecoder(body) 5518 t, err := smithyxml.FetchRootElement(rootDecoder) 5519 if err == io.EOF { 5520 return out, metadata, nil 5521 } 5522 if err != nil { 5523 var snapshot bytes.Buffer 5524 io.Copy(&snapshot, ringBuffer) 5525 return out, metadata, &smithy.DeserializationError{ 5526 Err: fmt.Errorf("failed to decode response body, %w", err), 5527 Snapshot: snapshot.Bytes(), 5528 } 5529 } 5530 5531 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5532 err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(&output, decoder) 5533 if err != nil { 5534 var snapshot bytes.Buffer 5535 io.Copy(&snapshot, ringBuffer) 5536 return out, metadata, &smithy.DeserializationError{ 5537 Err: fmt.Errorf("failed to decode response body, %w", err), 5538 Snapshot: snapshot.Bytes(), 5539 } 5540 } 5541 5542 return out, metadata, err 5543} 5544 5545func awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5546 var errorBuffer bytes.Buffer 5547 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5548 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5549 } 5550 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5551 5552 errorCode := "UnknownError" 5553 errorMessage := errorCode 5554 5555 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5556 if err != nil { 5557 return err 5558 } 5559 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5560 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5561 } 5562 if len(errorComponents.Code) != 0 { 5563 errorCode = errorComponents.Code 5564 } 5565 if len(errorComponents.Message) != 0 { 5566 errorMessage = errorComponents.Message 5567 } 5568 errorBody.Seek(0, io.SeekStart) 5569 switch { 5570 case strings.EqualFold("InvalidInput", errorCode): 5571 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5572 5573 case strings.EqualFold("NoSuchDelegationSet", errorCode): 5574 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 5575 5576 default: 5577 genericError := &smithy.GenericAPIError{ 5578 Code: errorCode, 5579 Message: errorMessage, 5580 } 5581 return genericError 5582 5583 } 5584} 5585 5586func awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(v **GetReusableDelegationSetLimitOutput, decoder smithyxml.NodeDecoder) error { 5587 if v == nil { 5588 return fmt.Errorf("unexpected nil of type %T", v) 5589 } 5590 var sv *GetReusableDelegationSetLimitOutput 5591 if *v == nil { 5592 sv = &GetReusableDelegationSetLimitOutput{} 5593 } else { 5594 sv = *v 5595 } 5596 5597 for { 5598 t, done, err := decoder.Token() 5599 if err != nil { 5600 return err 5601 } 5602 if done { 5603 break 5604 } 5605 originalDecoder := decoder 5606 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5607 switch { 5608 case strings.EqualFold("Count", t.Name.Local): 5609 val, err := decoder.Value() 5610 if err != nil { 5611 return err 5612 } 5613 if val == nil { 5614 break 5615 } 5616 { 5617 xtv := string(val) 5618 i64, err := strconv.ParseInt(xtv, 10, 64) 5619 if err != nil { 5620 return err 5621 } 5622 sv.Count = i64 5623 } 5624 5625 case strings.EqualFold("Limit", t.Name.Local): 5626 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5627 if err := awsRestxml_deserializeDocumentReusableDelegationSetLimit(&sv.Limit, nodeDecoder); err != nil { 5628 return err 5629 } 5630 5631 default: 5632 // Do nothing and ignore the unexpected tag element 5633 err = decoder.Decoder.Skip() 5634 if err != nil { 5635 return err 5636 } 5637 5638 } 5639 decoder = originalDecoder 5640 } 5641 *v = sv 5642 return nil 5643} 5644 5645type awsRestxml_deserializeOpGetTrafficPolicy struct { 5646} 5647 5648func (*awsRestxml_deserializeOpGetTrafficPolicy) ID() string { 5649 return "OperationDeserializer" 5650} 5651 5652func (m *awsRestxml_deserializeOpGetTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5653 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5654) { 5655 out, metadata, err = next.HandleDeserialize(ctx, in) 5656 if err != nil { 5657 return out, metadata, err 5658 } 5659 5660 response, ok := out.RawResponse.(*smithyhttp.Response) 5661 if !ok { 5662 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5663 } 5664 5665 if response.StatusCode < 200 || response.StatusCode >= 300 { 5666 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicy(response, &metadata) 5667 } 5668 output := &GetTrafficPolicyOutput{} 5669 out.Result = output 5670 5671 var buff [1024]byte 5672 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5673 body := io.TeeReader(response.Body, ringBuffer) 5674 rootDecoder := xml.NewDecoder(body) 5675 t, err := smithyxml.FetchRootElement(rootDecoder) 5676 if err == io.EOF { 5677 return out, metadata, nil 5678 } 5679 if err != nil { 5680 var snapshot bytes.Buffer 5681 io.Copy(&snapshot, ringBuffer) 5682 return out, metadata, &smithy.DeserializationError{ 5683 Err: fmt.Errorf("failed to decode response body, %w", err), 5684 Snapshot: snapshot.Bytes(), 5685 } 5686 } 5687 5688 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5689 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(&output, decoder) 5690 if err != nil { 5691 var snapshot bytes.Buffer 5692 io.Copy(&snapshot, ringBuffer) 5693 return out, metadata, &smithy.DeserializationError{ 5694 Err: fmt.Errorf("failed to decode response body, %w", err), 5695 Snapshot: snapshot.Bytes(), 5696 } 5697 } 5698 5699 return out, metadata, err 5700} 5701 5702func awsRestxml_deserializeOpErrorGetTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5703 var errorBuffer bytes.Buffer 5704 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5705 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5706 } 5707 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5708 5709 errorCode := "UnknownError" 5710 errorMessage := errorCode 5711 5712 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5713 if err != nil { 5714 return err 5715 } 5716 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5717 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5718 } 5719 if len(errorComponents.Code) != 0 { 5720 errorCode = errorComponents.Code 5721 } 5722 if len(errorComponents.Message) != 0 { 5723 errorMessage = errorComponents.Message 5724 } 5725 errorBody.Seek(0, io.SeekStart) 5726 switch { 5727 case strings.EqualFold("InvalidInput", errorCode): 5728 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5729 5730 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 5731 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 5732 5733 default: 5734 genericError := &smithy.GenericAPIError{ 5735 Code: errorCode, 5736 Message: errorMessage, 5737 } 5738 return genericError 5739 5740 } 5741} 5742 5743func awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(v **GetTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error { 5744 if v == nil { 5745 return fmt.Errorf("unexpected nil of type %T", v) 5746 } 5747 var sv *GetTrafficPolicyOutput 5748 if *v == nil { 5749 sv = &GetTrafficPolicyOutput{} 5750 } else { 5751 sv = *v 5752 } 5753 5754 for { 5755 t, done, err := decoder.Token() 5756 if err != nil { 5757 return err 5758 } 5759 if done { 5760 break 5761 } 5762 originalDecoder := decoder 5763 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5764 switch { 5765 case strings.EqualFold("TrafficPolicy", t.Name.Local): 5766 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5767 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 5768 return err 5769 } 5770 5771 default: 5772 // Do nothing and ignore the unexpected tag element 5773 err = decoder.Decoder.Skip() 5774 if err != nil { 5775 return err 5776 } 5777 5778 } 5779 decoder = originalDecoder 5780 } 5781 *v = sv 5782 return nil 5783} 5784 5785type awsRestxml_deserializeOpGetTrafficPolicyInstance struct { 5786} 5787 5788func (*awsRestxml_deserializeOpGetTrafficPolicyInstance) ID() string { 5789 return "OperationDeserializer" 5790} 5791 5792func (m *awsRestxml_deserializeOpGetTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5793 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5794) { 5795 out, metadata, err = next.HandleDeserialize(ctx, in) 5796 if err != nil { 5797 return out, metadata, err 5798 } 5799 5800 response, ok := out.RawResponse.(*smithyhttp.Response) 5801 if !ok { 5802 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5803 } 5804 5805 if response.StatusCode < 200 || response.StatusCode >= 300 { 5806 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response, &metadata) 5807 } 5808 output := &GetTrafficPolicyInstanceOutput{} 5809 out.Result = output 5810 5811 var buff [1024]byte 5812 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5813 body := io.TeeReader(response.Body, ringBuffer) 5814 rootDecoder := xml.NewDecoder(body) 5815 t, err := smithyxml.FetchRootElement(rootDecoder) 5816 if err == io.EOF { 5817 return out, metadata, nil 5818 } 5819 if err != nil { 5820 var snapshot bytes.Buffer 5821 io.Copy(&snapshot, ringBuffer) 5822 return out, metadata, &smithy.DeserializationError{ 5823 Err: fmt.Errorf("failed to decode response body, %w", err), 5824 Snapshot: snapshot.Bytes(), 5825 } 5826 } 5827 5828 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5829 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(&output, decoder) 5830 if err != nil { 5831 var snapshot bytes.Buffer 5832 io.Copy(&snapshot, ringBuffer) 5833 return out, metadata, &smithy.DeserializationError{ 5834 Err: fmt.Errorf("failed to decode response body, %w", err), 5835 Snapshot: snapshot.Bytes(), 5836 } 5837 } 5838 5839 return out, metadata, err 5840} 5841 5842func awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5843 var errorBuffer bytes.Buffer 5844 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5845 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5846 } 5847 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5848 5849 errorCode := "UnknownError" 5850 errorMessage := errorCode 5851 5852 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5853 if err != nil { 5854 return err 5855 } 5856 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5857 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5858 } 5859 if len(errorComponents.Code) != 0 { 5860 errorCode = errorComponents.Code 5861 } 5862 if len(errorComponents.Message) != 0 { 5863 errorMessage = errorComponents.Message 5864 } 5865 errorBody.Seek(0, io.SeekStart) 5866 switch { 5867 case strings.EqualFold("InvalidInput", errorCode): 5868 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5869 5870 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 5871 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 5872 5873 default: 5874 genericError := &smithy.GenericAPIError{ 5875 Code: errorCode, 5876 Message: errorMessage, 5877 } 5878 return genericError 5879 5880 } 5881} 5882 5883func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(v **GetTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error { 5884 if v == nil { 5885 return fmt.Errorf("unexpected nil of type %T", v) 5886 } 5887 var sv *GetTrafficPolicyInstanceOutput 5888 if *v == nil { 5889 sv = &GetTrafficPolicyInstanceOutput{} 5890 } else { 5891 sv = *v 5892 } 5893 5894 for { 5895 t, done, err := decoder.Token() 5896 if err != nil { 5897 return err 5898 } 5899 if done { 5900 break 5901 } 5902 originalDecoder := decoder 5903 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5904 switch { 5905 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 5906 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5907 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil { 5908 return err 5909 } 5910 5911 default: 5912 // Do nothing and ignore the unexpected tag element 5913 err = decoder.Decoder.Skip() 5914 if err != nil { 5915 return err 5916 } 5917 5918 } 5919 decoder = originalDecoder 5920 } 5921 *v = sv 5922 return nil 5923} 5924 5925type awsRestxml_deserializeOpGetTrafficPolicyInstanceCount struct { 5926} 5927 5928func (*awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) ID() string { 5929 return "OperationDeserializer" 5930} 5931 5932func (m *awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5933 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5934) { 5935 out, metadata, err = next.HandleDeserialize(ctx, in) 5936 if err != nil { 5937 return out, metadata, err 5938 } 5939 5940 response, ok := out.RawResponse.(*smithyhttp.Response) 5941 if !ok { 5942 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5943 } 5944 5945 if response.StatusCode < 200 || response.StatusCode >= 300 { 5946 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response, &metadata) 5947 } 5948 output := &GetTrafficPolicyInstanceCountOutput{} 5949 out.Result = output 5950 5951 var buff [1024]byte 5952 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5953 body := io.TeeReader(response.Body, ringBuffer) 5954 rootDecoder := xml.NewDecoder(body) 5955 t, err := smithyxml.FetchRootElement(rootDecoder) 5956 if err == io.EOF { 5957 return out, metadata, nil 5958 } 5959 if err != nil { 5960 var snapshot bytes.Buffer 5961 io.Copy(&snapshot, ringBuffer) 5962 return out, metadata, &smithy.DeserializationError{ 5963 Err: fmt.Errorf("failed to decode response body, %w", err), 5964 Snapshot: snapshot.Bytes(), 5965 } 5966 } 5967 5968 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5969 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(&output, decoder) 5970 if err != nil { 5971 var snapshot bytes.Buffer 5972 io.Copy(&snapshot, ringBuffer) 5973 return out, metadata, &smithy.DeserializationError{ 5974 Err: fmt.Errorf("failed to decode response body, %w", err), 5975 Snapshot: snapshot.Bytes(), 5976 } 5977 } 5978 5979 return out, metadata, err 5980} 5981 5982func awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5983 var errorBuffer bytes.Buffer 5984 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5985 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5986 } 5987 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5988 5989 errorCode := "UnknownError" 5990 errorMessage := errorCode 5991 5992 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5993 if err != nil { 5994 return err 5995 } 5996 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5997 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5998 } 5999 if len(errorComponents.Code) != 0 { 6000 errorCode = errorComponents.Code 6001 } 6002 if len(errorComponents.Message) != 0 { 6003 errorMessage = errorComponents.Message 6004 } 6005 errorBody.Seek(0, io.SeekStart) 6006 switch { 6007 default: 6008 genericError := &smithy.GenericAPIError{ 6009 Code: errorCode, 6010 Message: errorMessage, 6011 } 6012 return genericError 6013 6014 } 6015} 6016 6017func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(v **GetTrafficPolicyInstanceCountOutput, decoder smithyxml.NodeDecoder) error { 6018 if v == nil { 6019 return fmt.Errorf("unexpected nil of type %T", v) 6020 } 6021 var sv *GetTrafficPolicyInstanceCountOutput 6022 if *v == nil { 6023 sv = &GetTrafficPolicyInstanceCountOutput{} 6024 } else { 6025 sv = *v 6026 } 6027 6028 for { 6029 t, done, err := decoder.Token() 6030 if err != nil { 6031 return err 6032 } 6033 if done { 6034 break 6035 } 6036 originalDecoder := decoder 6037 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6038 switch { 6039 case strings.EqualFold("TrafficPolicyInstanceCount", t.Name.Local): 6040 val, err := decoder.Value() 6041 if err != nil { 6042 return err 6043 } 6044 if val == nil { 6045 break 6046 } 6047 { 6048 xtv := string(val) 6049 i64, err := strconv.ParseInt(xtv, 10, 64) 6050 if err != nil { 6051 return err 6052 } 6053 sv.TrafficPolicyInstanceCount = ptr.Int32(int32(i64)) 6054 } 6055 6056 default: 6057 // Do nothing and ignore the unexpected tag element 6058 err = decoder.Decoder.Skip() 6059 if err != nil { 6060 return err 6061 } 6062 6063 } 6064 decoder = originalDecoder 6065 } 6066 *v = sv 6067 return nil 6068} 6069 6070type awsRestxml_deserializeOpListGeoLocations struct { 6071} 6072 6073func (*awsRestxml_deserializeOpListGeoLocations) ID() string { 6074 return "OperationDeserializer" 6075} 6076 6077func (m *awsRestxml_deserializeOpListGeoLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6078 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6079) { 6080 out, metadata, err = next.HandleDeserialize(ctx, in) 6081 if err != nil { 6082 return out, metadata, err 6083 } 6084 6085 response, ok := out.RawResponse.(*smithyhttp.Response) 6086 if !ok { 6087 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6088 } 6089 6090 if response.StatusCode < 200 || response.StatusCode >= 300 { 6091 return out, metadata, awsRestxml_deserializeOpErrorListGeoLocations(response, &metadata) 6092 } 6093 output := &ListGeoLocationsOutput{} 6094 out.Result = output 6095 6096 var buff [1024]byte 6097 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6098 body := io.TeeReader(response.Body, ringBuffer) 6099 rootDecoder := xml.NewDecoder(body) 6100 t, err := smithyxml.FetchRootElement(rootDecoder) 6101 if err == io.EOF { 6102 return out, metadata, nil 6103 } 6104 if err != nil { 6105 var snapshot bytes.Buffer 6106 io.Copy(&snapshot, ringBuffer) 6107 return out, metadata, &smithy.DeserializationError{ 6108 Err: fmt.Errorf("failed to decode response body, %w", err), 6109 Snapshot: snapshot.Bytes(), 6110 } 6111 } 6112 6113 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6114 err = awsRestxml_deserializeOpDocumentListGeoLocationsOutput(&output, decoder) 6115 if err != nil { 6116 var snapshot bytes.Buffer 6117 io.Copy(&snapshot, ringBuffer) 6118 return out, metadata, &smithy.DeserializationError{ 6119 Err: fmt.Errorf("failed to decode response body, %w", err), 6120 Snapshot: snapshot.Bytes(), 6121 } 6122 } 6123 6124 return out, metadata, err 6125} 6126 6127func awsRestxml_deserializeOpErrorListGeoLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6128 var errorBuffer bytes.Buffer 6129 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6130 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6131 } 6132 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6133 6134 errorCode := "UnknownError" 6135 errorMessage := errorCode 6136 6137 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6138 if err != nil { 6139 return err 6140 } 6141 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6142 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6143 } 6144 if len(errorComponents.Code) != 0 { 6145 errorCode = errorComponents.Code 6146 } 6147 if len(errorComponents.Message) != 0 { 6148 errorMessage = errorComponents.Message 6149 } 6150 errorBody.Seek(0, io.SeekStart) 6151 switch { 6152 case strings.EqualFold("InvalidInput", errorCode): 6153 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6154 6155 default: 6156 genericError := &smithy.GenericAPIError{ 6157 Code: errorCode, 6158 Message: errorMessage, 6159 } 6160 return genericError 6161 6162 } 6163} 6164 6165func awsRestxml_deserializeOpDocumentListGeoLocationsOutput(v **ListGeoLocationsOutput, decoder smithyxml.NodeDecoder) error { 6166 if v == nil { 6167 return fmt.Errorf("unexpected nil of type %T", v) 6168 } 6169 var sv *ListGeoLocationsOutput 6170 if *v == nil { 6171 sv = &ListGeoLocationsOutput{} 6172 } else { 6173 sv = *v 6174 } 6175 6176 for { 6177 t, done, err := decoder.Token() 6178 if err != nil { 6179 return err 6180 } 6181 if done { 6182 break 6183 } 6184 originalDecoder := decoder 6185 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6186 switch { 6187 case strings.EqualFold("GeoLocationDetailsList", t.Name.Local): 6188 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6189 if err := awsRestxml_deserializeDocumentGeoLocationDetailsList(&sv.GeoLocationDetailsList, nodeDecoder); err != nil { 6190 return err 6191 } 6192 6193 case strings.EqualFold("IsTruncated", t.Name.Local): 6194 val, err := decoder.Value() 6195 if err != nil { 6196 return err 6197 } 6198 if val == nil { 6199 break 6200 } 6201 { 6202 xtv, err := strconv.ParseBool(string(val)) 6203 if err != nil { 6204 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6205 } 6206 sv.IsTruncated = xtv 6207 } 6208 6209 case strings.EqualFold("MaxItems", t.Name.Local): 6210 val, err := decoder.Value() 6211 if err != nil { 6212 return err 6213 } 6214 if val == nil { 6215 break 6216 } 6217 { 6218 xtv := string(val) 6219 i64, err := strconv.ParseInt(xtv, 10, 64) 6220 if err != nil { 6221 return err 6222 } 6223 sv.MaxItems = ptr.Int32(int32(i64)) 6224 } 6225 6226 case strings.EqualFold("NextContinentCode", t.Name.Local): 6227 val, err := decoder.Value() 6228 if err != nil { 6229 return err 6230 } 6231 if val == nil { 6232 break 6233 } 6234 { 6235 xtv := string(val) 6236 sv.NextContinentCode = ptr.String(xtv) 6237 } 6238 6239 case strings.EqualFold("NextCountryCode", t.Name.Local): 6240 val, err := decoder.Value() 6241 if err != nil { 6242 return err 6243 } 6244 if val == nil { 6245 break 6246 } 6247 { 6248 xtv := string(val) 6249 sv.NextCountryCode = ptr.String(xtv) 6250 } 6251 6252 case strings.EqualFold("NextSubdivisionCode", t.Name.Local): 6253 val, err := decoder.Value() 6254 if err != nil { 6255 return err 6256 } 6257 if val == nil { 6258 break 6259 } 6260 { 6261 xtv := string(val) 6262 sv.NextSubdivisionCode = ptr.String(xtv) 6263 } 6264 6265 default: 6266 // Do nothing and ignore the unexpected tag element 6267 err = decoder.Decoder.Skip() 6268 if err != nil { 6269 return err 6270 } 6271 6272 } 6273 decoder = originalDecoder 6274 } 6275 *v = sv 6276 return nil 6277} 6278 6279type awsRestxml_deserializeOpListHealthChecks struct { 6280} 6281 6282func (*awsRestxml_deserializeOpListHealthChecks) ID() string { 6283 return "OperationDeserializer" 6284} 6285 6286func (m *awsRestxml_deserializeOpListHealthChecks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6287 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6288) { 6289 out, metadata, err = next.HandleDeserialize(ctx, in) 6290 if err != nil { 6291 return out, metadata, err 6292 } 6293 6294 response, ok := out.RawResponse.(*smithyhttp.Response) 6295 if !ok { 6296 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6297 } 6298 6299 if response.StatusCode < 200 || response.StatusCode >= 300 { 6300 return out, metadata, awsRestxml_deserializeOpErrorListHealthChecks(response, &metadata) 6301 } 6302 output := &ListHealthChecksOutput{} 6303 out.Result = output 6304 6305 var buff [1024]byte 6306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6307 body := io.TeeReader(response.Body, ringBuffer) 6308 rootDecoder := xml.NewDecoder(body) 6309 t, err := smithyxml.FetchRootElement(rootDecoder) 6310 if err == io.EOF { 6311 return out, metadata, nil 6312 } 6313 if err != nil { 6314 var snapshot bytes.Buffer 6315 io.Copy(&snapshot, ringBuffer) 6316 return out, metadata, &smithy.DeserializationError{ 6317 Err: fmt.Errorf("failed to decode response body, %w", err), 6318 Snapshot: snapshot.Bytes(), 6319 } 6320 } 6321 6322 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6323 err = awsRestxml_deserializeOpDocumentListHealthChecksOutput(&output, decoder) 6324 if err != nil { 6325 var snapshot bytes.Buffer 6326 io.Copy(&snapshot, ringBuffer) 6327 return out, metadata, &smithy.DeserializationError{ 6328 Err: fmt.Errorf("failed to decode response body, %w", err), 6329 Snapshot: snapshot.Bytes(), 6330 } 6331 } 6332 6333 return out, metadata, err 6334} 6335 6336func awsRestxml_deserializeOpErrorListHealthChecks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6337 var errorBuffer bytes.Buffer 6338 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6339 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6340 } 6341 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6342 6343 errorCode := "UnknownError" 6344 errorMessage := errorCode 6345 6346 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6347 if err != nil { 6348 return err 6349 } 6350 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6351 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6352 } 6353 if len(errorComponents.Code) != 0 { 6354 errorCode = errorComponents.Code 6355 } 6356 if len(errorComponents.Message) != 0 { 6357 errorMessage = errorComponents.Message 6358 } 6359 errorBody.Seek(0, io.SeekStart) 6360 switch { 6361 case strings.EqualFold("IncompatibleVersion", errorCode): 6362 return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody) 6363 6364 case strings.EqualFold("InvalidInput", errorCode): 6365 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6366 6367 default: 6368 genericError := &smithy.GenericAPIError{ 6369 Code: errorCode, 6370 Message: errorMessage, 6371 } 6372 return genericError 6373 6374 } 6375} 6376 6377func awsRestxml_deserializeOpDocumentListHealthChecksOutput(v **ListHealthChecksOutput, decoder smithyxml.NodeDecoder) error { 6378 if v == nil { 6379 return fmt.Errorf("unexpected nil of type %T", v) 6380 } 6381 var sv *ListHealthChecksOutput 6382 if *v == nil { 6383 sv = &ListHealthChecksOutput{} 6384 } else { 6385 sv = *v 6386 } 6387 6388 for { 6389 t, done, err := decoder.Token() 6390 if err != nil { 6391 return err 6392 } 6393 if done { 6394 break 6395 } 6396 originalDecoder := decoder 6397 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6398 switch { 6399 case strings.EqualFold("HealthChecks", t.Name.Local): 6400 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6401 if err := awsRestxml_deserializeDocumentHealthChecks(&sv.HealthChecks, nodeDecoder); err != nil { 6402 return err 6403 } 6404 6405 case strings.EqualFold("IsTruncated", t.Name.Local): 6406 val, err := decoder.Value() 6407 if err != nil { 6408 return err 6409 } 6410 if val == nil { 6411 break 6412 } 6413 { 6414 xtv, err := strconv.ParseBool(string(val)) 6415 if err != nil { 6416 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6417 } 6418 sv.IsTruncated = xtv 6419 } 6420 6421 case strings.EqualFold("Marker", t.Name.Local): 6422 val, err := decoder.Value() 6423 if err != nil { 6424 return err 6425 } 6426 if val == nil { 6427 break 6428 } 6429 { 6430 xtv := string(val) 6431 sv.Marker = ptr.String(xtv) 6432 } 6433 6434 case strings.EqualFold("MaxItems", t.Name.Local): 6435 val, err := decoder.Value() 6436 if err != nil { 6437 return err 6438 } 6439 if val == nil { 6440 break 6441 } 6442 { 6443 xtv := string(val) 6444 i64, err := strconv.ParseInt(xtv, 10, 64) 6445 if err != nil { 6446 return err 6447 } 6448 sv.MaxItems = ptr.Int32(int32(i64)) 6449 } 6450 6451 case strings.EqualFold("NextMarker", t.Name.Local): 6452 val, err := decoder.Value() 6453 if err != nil { 6454 return err 6455 } 6456 if val == nil { 6457 break 6458 } 6459 { 6460 xtv := string(val) 6461 sv.NextMarker = ptr.String(xtv) 6462 } 6463 6464 default: 6465 // Do nothing and ignore the unexpected tag element 6466 err = decoder.Decoder.Skip() 6467 if err != nil { 6468 return err 6469 } 6470 6471 } 6472 decoder = originalDecoder 6473 } 6474 *v = sv 6475 return nil 6476} 6477 6478type awsRestxml_deserializeOpListHostedZones struct { 6479} 6480 6481func (*awsRestxml_deserializeOpListHostedZones) ID() string { 6482 return "OperationDeserializer" 6483} 6484 6485func (m *awsRestxml_deserializeOpListHostedZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6486 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6487) { 6488 out, metadata, err = next.HandleDeserialize(ctx, in) 6489 if err != nil { 6490 return out, metadata, err 6491 } 6492 6493 response, ok := out.RawResponse.(*smithyhttp.Response) 6494 if !ok { 6495 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6496 } 6497 6498 if response.StatusCode < 200 || response.StatusCode >= 300 { 6499 return out, metadata, awsRestxml_deserializeOpErrorListHostedZones(response, &metadata) 6500 } 6501 output := &ListHostedZonesOutput{} 6502 out.Result = output 6503 6504 var buff [1024]byte 6505 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6506 body := io.TeeReader(response.Body, ringBuffer) 6507 rootDecoder := xml.NewDecoder(body) 6508 t, err := smithyxml.FetchRootElement(rootDecoder) 6509 if err == io.EOF { 6510 return out, metadata, nil 6511 } 6512 if err != nil { 6513 var snapshot bytes.Buffer 6514 io.Copy(&snapshot, ringBuffer) 6515 return out, metadata, &smithy.DeserializationError{ 6516 Err: fmt.Errorf("failed to decode response body, %w", err), 6517 Snapshot: snapshot.Bytes(), 6518 } 6519 } 6520 6521 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6522 err = awsRestxml_deserializeOpDocumentListHostedZonesOutput(&output, decoder) 6523 if err != nil { 6524 var snapshot bytes.Buffer 6525 io.Copy(&snapshot, ringBuffer) 6526 return out, metadata, &smithy.DeserializationError{ 6527 Err: fmt.Errorf("failed to decode response body, %w", err), 6528 Snapshot: snapshot.Bytes(), 6529 } 6530 } 6531 6532 return out, metadata, err 6533} 6534 6535func awsRestxml_deserializeOpErrorListHostedZones(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6536 var errorBuffer bytes.Buffer 6537 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6538 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6539 } 6540 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6541 6542 errorCode := "UnknownError" 6543 errorMessage := errorCode 6544 6545 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6546 if err != nil { 6547 return err 6548 } 6549 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6550 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6551 } 6552 if len(errorComponents.Code) != 0 { 6553 errorCode = errorComponents.Code 6554 } 6555 if len(errorComponents.Message) != 0 { 6556 errorMessage = errorComponents.Message 6557 } 6558 errorBody.Seek(0, io.SeekStart) 6559 switch { 6560 case strings.EqualFold("DelegationSetNotReusable", errorCode): 6561 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 6562 6563 case strings.EqualFold("InvalidInput", errorCode): 6564 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6565 6566 case strings.EqualFold("NoSuchDelegationSet", errorCode): 6567 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 6568 6569 default: 6570 genericError := &smithy.GenericAPIError{ 6571 Code: errorCode, 6572 Message: errorMessage, 6573 } 6574 return genericError 6575 6576 } 6577} 6578 6579func awsRestxml_deserializeOpDocumentListHostedZonesOutput(v **ListHostedZonesOutput, decoder smithyxml.NodeDecoder) error { 6580 if v == nil { 6581 return fmt.Errorf("unexpected nil of type %T", v) 6582 } 6583 var sv *ListHostedZonesOutput 6584 if *v == nil { 6585 sv = &ListHostedZonesOutput{} 6586 } else { 6587 sv = *v 6588 } 6589 6590 for { 6591 t, done, err := decoder.Token() 6592 if err != nil { 6593 return err 6594 } 6595 if done { 6596 break 6597 } 6598 originalDecoder := decoder 6599 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6600 switch { 6601 case strings.EqualFold("HostedZones", t.Name.Local): 6602 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6603 if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil { 6604 return err 6605 } 6606 6607 case strings.EqualFold("IsTruncated", t.Name.Local): 6608 val, err := decoder.Value() 6609 if err != nil { 6610 return err 6611 } 6612 if val == nil { 6613 break 6614 } 6615 { 6616 xtv, err := strconv.ParseBool(string(val)) 6617 if err != nil { 6618 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6619 } 6620 sv.IsTruncated = xtv 6621 } 6622 6623 case strings.EqualFold("Marker", t.Name.Local): 6624 val, err := decoder.Value() 6625 if err != nil { 6626 return err 6627 } 6628 if val == nil { 6629 break 6630 } 6631 { 6632 xtv := string(val) 6633 sv.Marker = ptr.String(xtv) 6634 } 6635 6636 case strings.EqualFold("MaxItems", t.Name.Local): 6637 val, err := decoder.Value() 6638 if err != nil { 6639 return err 6640 } 6641 if val == nil { 6642 break 6643 } 6644 { 6645 xtv := string(val) 6646 i64, err := strconv.ParseInt(xtv, 10, 64) 6647 if err != nil { 6648 return err 6649 } 6650 sv.MaxItems = ptr.Int32(int32(i64)) 6651 } 6652 6653 case strings.EqualFold("NextMarker", t.Name.Local): 6654 val, err := decoder.Value() 6655 if err != nil { 6656 return err 6657 } 6658 if val == nil { 6659 break 6660 } 6661 { 6662 xtv := string(val) 6663 sv.NextMarker = ptr.String(xtv) 6664 } 6665 6666 default: 6667 // Do nothing and ignore the unexpected tag element 6668 err = decoder.Decoder.Skip() 6669 if err != nil { 6670 return err 6671 } 6672 6673 } 6674 decoder = originalDecoder 6675 } 6676 *v = sv 6677 return nil 6678} 6679 6680type awsRestxml_deserializeOpListHostedZonesByName struct { 6681} 6682 6683func (*awsRestxml_deserializeOpListHostedZonesByName) ID() string { 6684 return "OperationDeserializer" 6685} 6686 6687func (m *awsRestxml_deserializeOpListHostedZonesByName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6688 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6689) { 6690 out, metadata, err = next.HandleDeserialize(ctx, in) 6691 if err != nil { 6692 return out, metadata, err 6693 } 6694 6695 response, ok := out.RawResponse.(*smithyhttp.Response) 6696 if !ok { 6697 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6698 } 6699 6700 if response.StatusCode < 200 || response.StatusCode >= 300 { 6701 return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByName(response, &metadata) 6702 } 6703 output := &ListHostedZonesByNameOutput{} 6704 out.Result = output 6705 6706 var buff [1024]byte 6707 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6708 body := io.TeeReader(response.Body, ringBuffer) 6709 rootDecoder := xml.NewDecoder(body) 6710 t, err := smithyxml.FetchRootElement(rootDecoder) 6711 if err == io.EOF { 6712 return out, metadata, nil 6713 } 6714 if err != nil { 6715 var snapshot bytes.Buffer 6716 io.Copy(&snapshot, ringBuffer) 6717 return out, metadata, &smithy.DeserializationError{ 6718 Err: fmt.Errorf("failed to decode response body, %w", err), 6719 Snapshot: snapshot.Bytes(), 6720 } 6721 } 6722 6723 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6724 err = awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(&output, decoder) 6725 if err != nil { 6726 var snapshot bytes.Buffer 6727 io.Copy(&snapshot, ringBuffer) 6728 return out, metadata, &smithy.DeserializationError{ 6729 Err: fmt.Errorf("failed to decode response body, %w", err), 6730 Snapshot: snapshot.Bytes(), 6731 } 6732 } 6733 6734 return out, metadata, err 6735} 6736 6737func awsRestxml_deserializeOpErrorListHostedZonesByName(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6738 var errorBuffer bytes.Buffer 6739 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6740 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6741 } 6742 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6743 6744 errorCode := "UnknownError" 6745 errorMessage := errorCode 6746 6747 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6748 if err != nil { 6749 return err 6750 } 6751 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6752 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6753 } 6754 if len(errorComponents.Code) != 0 { 6755 errorCode = errorComponents.Code 6756 } 6757 if len(errorComponents.Message) != 0 { 6758 errorMessage = errorComponents.Message 6759 } 6760 errorBody.Seek(0, io.SeekStart) 6761 switch { 6762 case strings.EqualFold("InvalidDomainName", errorCode): 6763 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody) 6764 6765 case strings.EqualFold("InvalidInput", errorCode): 6766 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6767 6768 default: 6769 genericError := &smithy.GenericAPIError{ 6770 Code: errorCode, 6771 Message: errorMessage, 6772 } 6773 return genericError 6774 6775 } 6776} 6777 6778func awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(v **ListHostedZonesByNameOutput, decoder smithyxml.NodeDecoder) error { 6779 if v == nil { 6780 return fmt.Errorf("unexpected nil of type %T", v) 6781 } 6782 var sv *ListHostedZonesByNameOutput 6783 if *v == nil { 6784 sv = &ListHostedZonesByNameOutput{} 6785 } else { 6786 sv = *v 6787 } 6788 6789 for { 6790 t, done, err := decoder.Token() 6791 if err != nil { 6792 return err 6793 } 6794 if done { 6795 break 6796 } 6797 originalDecoder := decoder 6798 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6799 switch { 6800 case strings.EqualFold("DNSName", t.Name.Local): 6801 val, err := decoder.Value() 6802 if err != nil { 6803 return err 6804 } 6805 if val == nil { 6806 break 6807 } 6808 { 6809 xtv := string(val) 6810 sv.DNSName = ptr.String(xtv) 6811 } 6812 6813 case strings.EqualFold("HostedZoneId", t.Name.Local): 6814 val, err := decoder.Value() 6815 if err != nil { 6816 return err 6817 } 6818 if val == nil { 6819 break 6820 } 6821 { 6822 xtv := string(val) 6823 sv.HostedZoneId = ptr.String(xtv) 6824 } 6825 6826 case strings.EqualFold("HostedZones", t.Name.Local): 6827 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6828 if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil { 6829 return err 6830 } 6831 6832 case strings.EqualFold("IsTruncated", t.Name.Local): 6833 val, err := decoder.Value() 6834 if err != nil { 6835 return err 6836 } 6837 if val == nil { 6838 break 6839 } 6840 { 6841 xtv, err := strconv.ParseBool(string(val)) 6842 if err != nil { 6843 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6844 } 6845 sv.IsTruncated = xtv 6846 } 6847 6848 case strings.EqualFold("MaxItems", t.Name.Local): 6849 val, err := decoder.Value() 6850 if err != nil { 6851 return err 6852 } 6853 if val == nil { 6854 break 6855 } 6856 { 6857 xtv := string(val) 6858 i64, err := strconv.ParseInt(xtv, 10, 64) 6859 if err != nil { 6860 return err 6861 } 6862 sv.MaxItems = ptr.Int32(int32(i64)) 6863 } 6864 6865 case strings.EqualFold("NextDNSName", t.Name.Local): 6866 val, err := decoder.Value() 6867 if err != nil { 6868 return err 6869 } 6870 if val == nil { 6871 break 6872 } 6873 { 6874 xtv := string(val) 6875 sv.NextDNSName = ptr.String(xtv) 6876 } 6877 6878 case strings.EqualFold("NextHostedZoneId", t.Name.Local): 6879 val, err := decoder.Value() 6880 if err != nil { 6881 return err 6882 } 6883 if val == nil { 6884 break 6885 } 6886 { 6887 xtv := string(val) 6888 sv.NextHostedZoneId = ptr.String(xtv) 6889 } 6890 6891 default: 6892 // Do nothing and ignore the unexpected tag element 6893 err = decoder.Decoder.Skip() 6894 if err != nil { 6895 return err 6896 } 6897 6898 } 6899 decoder = originalDecoder 6900 } 6901 *v = sv 6902 return nil 6903} 6904 6905type awsRestxml_deserializeOpListHostedZonesByVPC struct { 6906} 6907 6908func (*awsRestxml_deserializeOpListHostedZonesByVPC) ID() string { 6909 return "OperationDeserializer" 6910} 6911 6912func (m *awsRestxml_deserializeOpListHostedZonesByVPC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6913 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6914) { 6915 out, metadata, err = next.HandleDeserialize(ctx, in) 6916 if err != nil { 6917 return out, metadata, err 6918 } 6919 6920 response, ok := out.RawResponse.(*smithyhttp.Response) 6921 if !ok { 6922 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6923 } 6924 6925 if response.StatusCode < 200 || response.StatusCode >= 300 { 6926 return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByVPC(response, &metadata) 6927 } 6928 output := &ListHostedZonesByVPCOutput{} 6929 out.Result = output 6930 6931 var buff [1024]byte 6932 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6933 body := io.TeeReader(response.Body, ringBuffer) 6934 rootDecoder := xml.NewDecoder(body) 6935 t, err := smithyxml.FetchRootElement(rootDecoder) 6936 if err == io.EOF { 6937 return out, metadata, nil 6938 } 6939 if err != nil { 6940 var snapshot bytes.Buffer 6941 io.Copy(&snapshot, ringBuffer) 6942 return out, metadata, &smithy.DeserializationError{ 6943 Err: fmt.Errorf("failed to decode response body, %w", err), 6944 Snapshot: snapshot.Bytes(), 6945 } 6946 } 6947 6948 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6949 err = awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(&output, decoder) 6950 if err != nil { 6951 var snapshot bytes.Buffer 6952 io.Copy(&snapshot, ringBuffer) 6953 return out, metadata, &smithy.DeserializationError{ 6954 Err: fmt.Errorf("failed to decode response body, %w", err), 6955 Snapshot: snapshot.Bytes(), 6956 } 6957 } 6958 6959 return out, metadata, err 6960} 6961 6962func awsRestxml_deserializeOpErrorListHostedZonesByVPC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6963 var errorBuffer bytes.Buffer 6964 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6965 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6966 } 6967 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6968 6969 errorCode := "UnknownError" 6970 errorMessage := errorCode 6971 6972 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6973 if err != nil { 6974 return err 6975 } 6976 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6977 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6978 } 6979 if len(errorComponents.Code) != 0 { 6980 errorCode = errorComponents.Code 6981 } 6982 if len(errorComponents.Message) != 0 { 6983 errorMessage = errorComponents.Message 6984 } 6985 errorBody.Seek(0, io.SeekStart) 6986 switch { 6987 case strings.EqualFold("InvalidInput", errorCode): 6988 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6989 6990 case strings.EqualFold("InvalidPaginationToken", errorCode): 6991 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody) 6992 6993 default: 6994 genericError := &smithy.GenericAPIError{ 6995 Code: errorCode, 6996 Message: errorMessage, 6997 } 6998 return genericError 6999 7000 } 7001} 7002 7003func awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(v **ListHostedZonesByVPCOutput, decoder smithyxml.NodeDecoder) error { 7004 if v == nil { 7005 return fmt.Errorf("unexpected nil of type %T", v) 7006 } 7007 var sv *ListHostedZonesByVPCOutput 7008 if *v == nil { 7009 sv = &ListHostedZonesByVPCOutput{} 7010 } else { 7011 sv = *v 7012 } 7013 7014 for { 7015 t, done, err := decoder.Token() 7016 if err != nil { 7017 return err 7018 } 7019 if done { 7020 break 7021 } 7022 originalDecoder := decoder 7023 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7024 switch { 7025 case strings.EqualFold("HostedZoneSummaries", t.Name.Local): 7026 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7027 if err := awsRestxml_deserializeDocumentHostedZoneSummaries(&sv.HostedZoneSummaries, nodeDecoder); err != nil { 7028 return err 7029 } 7030 7031 case strings.EqualFold("MaxItems", t.Name.Local): 7032 val, err := decoder.Value() 7033 if err != nil { 7034 return err 7035 } 7036 if val == nil { 7037 break 7038 } 7039 { 7040 xtv := string(val) 7041 i64, err := strconv.ParseInt(xtv, 10, 64) 7042 if err != nil { 7043 return err 7044 } 7045 sv.MaxItems = ptr.Int32(int32(i64)) 7046 } 7047 7048 case strings.EqualFold("NextToken", t.Name.Local): 7049 val, err := decoder.Value() 7050 if err != nil { 7051 return err 7052 } 7053 if val == nil { 7054 break 7055 } 7056 { 7057 xtv := string(val) 7058 sv.NextToken = ptr.String(xtv) 7059 } 7060 7061 default: 7062 // Do nothing and ignore the unexpected tag element 7063 err = decoder.Decoder.Skip() 7064 if err != nil { 7065 return err 7066 } 7067 7068 } 7069 decoder = originalDecoder 7070 } 7071 *v = sv 7072 return nil 7073} 7074 7075type awsRestxml_deserializeOpListQueryLoggingConfigs struct { 7076} 7077 7078func (*awsRestxml_deserializeOpListQueryLoggingConfigs) ID() string { 7079 return "OperationDeserializer" 7080} 7081 7082func (m *awsRestxml_deserializeOpListQueryLoggingConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7083 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7084) { 7085 out, metadata, err = next.HandleDeserialize(ctx, in) 7086 if err != nil { 7087 return out, metadata, err 7088 } 7089 7090 response, ok := out.RawResponse.(*smithyhttp.Response) 7091 if !ok { 7092 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7093 } 7094 7095 if response.StatusCode < 200 || response.StatusCode >= 300 { 7096 return out, metadata, awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response, &metadata) 7097 } 7098 output := &ListQueryLoggingConfigsOutput{} 7099 out.Result = output 7100 7101 var buff [1024]byte 7102 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7103 body := io.TeeReader(response.Body, ringBuffer) 7104 rootDecoder := xml.NewDecoder(body) 7105 t, err := smithyxml.FetchRootElement(rootDecoder) 7106 if err == io.EOF { 7107 return out, metadata, nil 7108 } 7109 if err != nil { 7110 var snapshot bytes.Buffer 7111 io.Copy(&snapshot, ringBuffer) 7112 return out, metadata, &smithy.DeserializationError{ 7113 Err: fmt.Errorf("failed to decode response body, %w", err), 7114 Snapshot: snapshot.Bytes(), 7115 } 7116 } 7117 7118 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7119 err = awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(&output, decoder) 7120 if err != nil { 7121 var snapshot bytes.Buffer 7122 io.Copy(&snapshot, ringBuffer) 7123 return out, metadata, &smithy.DeserializationError{ 7124 Err: fmt.Errorf("failed to decode response body, %w", err), 7125 Snapshot: snapshot.Bytes(), 7126 } 7127 } 7128 7129 return out, metadata, err 7130} 7131 7132func awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7133 var errorBuffer bytes.Buffer 7134 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7135 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7136 } 7137 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7138 7139 errorCode := "UnknownError" 7140 errorMessage := errorCode 7141 7142 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7143 if err != nil { 7144 return err 7145 } 7146 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7147 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7148 } 7149 if len(errorComponents.Code) != 0 { 7150 errorCode = errorComponents.Code 7151 } 7152 if len(errorComponents.Message) != 0 { 7153 errorMessage = errorComponents.Message 7154 } 7155 errorBody.Seek(0, io.SeekStart) 7156 switch { 7157 case strings.EqualFold("InvalidInput", errorCode): 7158 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7159 7160 case strings.EqualFold("InvalidPaginationToken", errorCode): 7161 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody) 7162 7163 case strings.EqualFold("NoSuchHostedZone", errorCode): 7164 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7165 7166 default: 7167 genericError := &smithy.GenericAPIError{ 7168 Code: errorCode, 7169 Message: errorMessage, 7170 } 7171 return genericError 7172 7173 } 7174} 7175 7176func awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(v **ListQueryLoggingConfigsOutput, decoder smithyxml.NodeDecoder) error { 7177 if v == nil { 7178 return fmt.Errorf("unexpected nil of type %T", v) 7179 } 7180 var sv *ListQueryLoggingConfigsOutput 7181 if *v == nil { 7182 sv = &ListQueryLoggingConfigsOutput{} 7183 } else { 7184 sv = *v 7185 } 7186 7187 for { 7188 t, done, err := decoder.Token() 7189 if err != nil { 7190 return err 7191 } 7192 if done { 7193 break 7194 } 7195 originalDecoder := decoder 7196 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7197 switch { 7198 case strings.EqualFold("NextToken", t.Name.Local): 7199 val, err := decoder.Value() 7200 if err != nil { 7201 return err 7202 } 7203 if val == nil { 7204 break 7205 } 7206 { 7207 xtv := string(val) 7208 sv.NextToken = ptr.String(xtv) 7209 } 7210 7211 case strings.EqualFold("QueryLoggingConfigs", t.Name.Local): 7212 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7213 if err := awsRestxml_deserializeDocumentQueryLoggingConfigs(&sv.QueryLoggingConfigs, nodeDecoder); err != nil { 7214 return err 7215 } 7216 7217 default: 7218 // Do nothing and ignore the unexpected tag element 7219 err = decoder.Decoder.Skip() 7220 if err != nil { 7221 return err 7222 } 7223 7224 } 7225 decoder = originalDecoder 7226 } 7227 *v = sv 7228 return nil 7229} 7230 7231type awsRestxml_deserializeOpListResourceRecordSets struct { 7232} 7233 7234func (*awsRestxml_deserializeOpListResourceRecordSets) ID() string { 7235 return "OperationDeserializer" 7236} 7237 7238func (m *awsRestxml_deserializeOpListResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7239 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7240) { 7241 out, metadata, err = next.HandleDeserialize(ctx, in) 7242 if err != nil { 7243 return out, metadata, err 7244 } 7245 7246 response, ok := out.RawResponse.(*smithyhttp.Response) 7247 if !ok { 7248 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7249 } 7250 7251 if response.StatusCode < 200 || response.StatusCode >= 300 { 7252 return out, metadata, awsRestxml_deserializeOpErrorListResourceRecordSets(response, &metadata) 7253 } 7254 output := &ListResourceRecordSetsOutput{} 7255 out.Result = output 7256 7257 var buff [1024]byte 7258 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7259 body := io.TeeReader(response.Body, ringBuffer) 7260 rootDecoder := xml.NewDecoder(body) 7261 t, err := smithyxml.FetchRootElement(rootDecoder) 7262 if err == io.EOF { 7263 return out, metadata, nil 7264 } 7265 if err != nil { 7266 var snapshot bytes.Buffer 7267 io.Copy(&snapshot, ringBuffer) 7268 return out, metadata, &smithy.DeserializationError{ 7269 Err: fmt.Errorf("failed to decode response body, %w", err), 7270 Snapshot: snapshot.Bytes(), 7271 } 7272 } 7273 7274 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7275 err = awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(&output, decoder) 7276 if err != nil { 7277 var snapshot bytes.Buffer 7278 io.Copy(&snapshot, ringBuffer) 7279 return out, metadata, &smithy.DeserializationError{ 7280 Err: fmt.Errorf("failed to decode response body, %w", err), 7281 Snapshot: snapshot.Bytes(), 7282 } 7283 } 7284 7285 return out, metadata, err 7286} 7287 7288func awsRestxml_deserializeOpErrorListResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7289 var errorBuffer bytes.Buffer 7290 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7291 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7292 } 7293 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7294 7295 errorCode := "UnknownError" 7296 errorMessage := errorCode 7297 7298 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7299 if err != nil { 7300 return err 7301 } 7302 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7303 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7304 } 7305 if len(errorComponents.Code) != 0 { 7306 errorCode = errorComponents.Code 7307 } 7308 if len(errorComponents.Message) != 0 { 7309 errorMessage = errorComponents.Message 7310 } 7311 errorBody.Seek(0, io.SeekStart) 7312 switch { 7313 case strings.EqualFold("InvalidInput", errorCode): 7314 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7315 7316 case strings.EqualFold("NoSuchHostedZone", errorCode): 7317 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7318 7319 default: 7320 genericError := &smithy.GenericAPIError{ 7321 Code: errorCode, 7322 Message: errorMessage, 7323 } 7324 return genericError 7325 7326 } 7327} 7328 7329func awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(v **ListResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error { 7330 if v == nil { 7331 return fmt.Errorf("unexpected nil of type %T", v) 7332 } 7333 var sv *ListResourceRecordSetsOutput 7334 if *v == nil { 7335 sv = &ListResourceRecordSetsOutput{} 7336 } else { 7337 sv = *v 7338 } 7339 7340 for { 7341 t, done, err := decoder.Token() 7342 if err != nil { 7343 return err 7344 } 7345 if done { 7346 break 7347 } 7348 originalDecoder := decoder 7349 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7350 switch { 7351 case strings.EqualFold("IsTruncated", t.Name.Local): 7352 val, err := decoder.Value() 7353 if err != nil { 7354 return err 7355 } 7356 if val == nil { 7357 break 7358 } 7359 { 7360 xtv, err := strconv.ParseBool(string(val)) 7361 if err != nil { 7362 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 7363 } 7364 sv.IsTruncated = xtv 7365 } 7366 7367 case strings.EqualFold("MaxItems", t.Name.Local): 7368 val, err := decoder.Value() 7369 if err != nil { 7370 return err 7371 } 7372 if val == nil { 7373 break 7374 } 7375 { 7376 xtv := string(val) 7377 i64, err := strconv.ParseInt(xtv, 10, 64) 7378 if err != nil { 7379 return err 7380 } 7381 sv.MaxItems = ptr.Int32(int32(i64)) 7382 } 7383 7384 case strings.EqualFold("NextRecordIdentifier", t.Name.Local): 7385 val, err := decoder.Value() 7386 if err != nil { 7387 return err 7388 } 7389 if val == nil { 7390 break 7391 } 7392 { 7393 xtv := string(val) 7394 sv.NextRecordIdentifier = ptr.String(xtv) 7395 } 7396 7397 case strings.EqualFold("NextRecordName", t.Name.Local): 7398 val, err := decoder.Value() 7399 if err != nil { 7400 return err 7401 } 7402 if val == nil { 7403 break 7404 } 7405 { 7406 xtv := string(val) 7407 sv.NextRecordName = ptr.String(xtv) 7408 } 7409 7410 case strings.EqualFold("NextRecordType", t.Name.Local): 7411 val, err := decoder.Value() 7412 if err != nil { 7413 return err 7414 } 7415 if val == nil { 7416 break 7417 } 7418 { 7419 xtv := string(val) 7420 sv.NextRecordType = types.RRType(xtv) 7421 } 7422 7423 case strings.EqualFold("ResourceRecordSets", t.Name.Local): 7424 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7425 if err := awsRestxml_deserializeDocumentResourceRecordSets(&sv.ResourceRecordSets, nodeDecoder); err != nil { 7426 return err 7427 } 7428 7429 default: 7430 // Do nothing and ignore the unexpected tag element 7431 err = decoder.Decoder.Skip() 7432 if err != nil { 7433 return err 7434 } 7435 7436 } 7437 decoder = originalDecoder 7438 } 7439 *v = sv 7440 return nil 7441} 7442 7443type awsRestxml_deserializeOpListReusableDelegationSets struct { 7444} 7445 7446func (*awsRestxml_deserializeOpListReusableDelegationSets) ID() string { 7447 return "OperationDeserializer" 7448} 7449 7450func (m *awsRestxml_deserializeOpListReusableDelegationSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7451 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7452) { 7453 out, metadata, err = next.HandleDeserialize(ctx, in) 7454 if err != nil { 7455 return out, metadata, err 7456 } 7457 7458 response, ok := out.RawResponse.(*smithyhttp.Response) 7459 if !ok { 7460 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7461 } 7462 7463 if response.StatusCode < 200 || response.StatusCode >= 300 { 7464 return out, metadata, awsRestxml_deserializeOpErrorListReusableDelegationSets(response, &metadata) 7465 } 7466 output := &ListReusableDelegationSetsOutput{} 7467 out.Result = output 7468 7469 var buff [1024]byte 7470 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7471 body := io.TeeReader(response.Body, ringBuffer) 7472 rootDecoder := xml.NewDecoder(body) 7473 t, err := smithyxml.FetchRootElement(rootDecoder) 7474 if err == io.EOF { 7475 return out, metadata, nil 7476 } 7477 if err != nil { 7478 var snapshot bytes.Buffer 7479 io.Copy(&snapshot, ringBuffer) 7480 return out, metadata, &smithy.DeserializationError{ 7481 Err: fmt.Errorf("failed to decode response body, %w", err), 7482 Snapshot: snapshot.Bytes(), 7483 } 7484 } 7485 7486 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7487 err = awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(&output, decoder) 7488 if err != nil { 7489 var snapshot bytes.Buffer 7490 io.Copy(&snapshot, ringBuffer) 7491 return out, metadata, &smithy.DeserializationError{ 7492 Err: fmt.Errorf("failed to decode response body, %w", err), 7493 Snapshot: snapshot.Bytes(), 7494 } 7495 } 7496 7497 return out, metadata, err 7498} 7499 7500func awsRestxml_deserializeOpErrorListReusableDelegationSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7501 var errorBuffer bytes.Buffer 7502 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7503 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7504 } 7505 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7506 7507 errorCode := "UnknownError" 7508 errorMessage := errorCode 7509 7510 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7511 if err != nil { 7512 return err 7513 } 7514 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7515 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7516 } 7517 if len(errorComponents.Code) != 0 { 7518 errorCode = errorComponents.Code 7519 } 7520 if len(errorComponents.Message) != 0 { 7521 errorMessage = errorComponents.Message 7522 } 7523 errorBody.Seek(0, io.SeekStart) 7524 switch { 7525 case strings.EqualFold("InvalidInput", errorCode): 7526 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7527 7528 default: 7529 genericError := &smithy.GenericAPIError{ 7530 Code: errorCode, 7531 Message: errorMessage, 7532 } 7533 return genericError 7534 7535 } 7536} 7537 7538func awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(v **ListReusableDelegationSetsOutput, decoder smithyxml.NodeDecoder) error { 7539 if v == nil { 7540 return fmt.Errorf("unexpected nil of type %T", v) 7541 } 7542 var sv *ListReusableDelegationSetsOutput 7543 if *v == nil { 7544 sv = &ListReusableDelegationSetsOutput{} 7545 } else { 7546 sv = *v 7547 } 7548 7549 for { 7550 t, done, err := decoder.Token() 7551 if err != nil { 7552 return err 7553 } 7554 if done { 7555 break 7556 } 7557 originalDecoder := decoder 7558 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7559 switch { 7560 case strings.EqualFold("DelegationSets", t.Name.Local): 7561 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7562 if err := awsRestxml_deserializeDocumentDelegationSets(&sv.DelegationSets, nodeDecoder); err != nil { 7563 return err 7564 } 7565 7566 case strings.EqualFold("IsTruncated", t.Name.Local): 7567 val, err := decoder.Value() 7568 if err != nil { 7569 return err 7570 } 7571 if val == nil { 7572 break 7573 } 7574 { 7575 xtv, err := strconv.ParseBool(string(val)) 7576 if err != nil { 7577 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 7578 } 7579 sv.IsTruncated = xtv 7580 } 7581 7582 case strings.EqualFold("Marker", t.Name.Local): 7583 val, err := decoder.Value() 7584 if err != nil { 7585 return err 7586 } 7587 if val == nil { 7588 break 7589 } 7590 { 7591 xtv := string(val) 7592 sv.Marker = ptr.String(xtv) 7593 } 7594 7595 case strings.EqualFold("MaxItems", t.Name.Local): 7596 val, err := decoder.Value() 7597 if err != nil { 7598 return err 7599 } 7600 if val == nil { 7601 break 7602 } 7603 { 7604 xtv := string(val) 7605 i64, err := strconv.ParseInt(xtv, 10, 64) 7606 if err != nil { 7607 return err 7608 } 7609 sv.MaxItems = ptr.Int32(int32(i64)) 7610 } 7611 7612 case strings.EqualFold("NextMarker", t.Name.Local): 7613 val, err := decoder.Value() 7614 if err != nil { 7615 return err 7616 } 7617 if val == nil { 7618 break 7619 } 7620 { 7621 xtv := string(val) 7622 sv.NextMarker = ptr.String(xtv) 7623 } 7624 7625 default: 7626 // Do nothing and ignore the unexpected tag element 7627 err = decoder.Decoder.Skip() 7628 if err != nil { 7629 return err 7630 } 7631 7632 } 7633 decoder = originalDecoder 7634 } 7635 *v = sv 7636 return nil 7637} 7638 7639type awsRestxml_deserializeOpListTagsForResource struct { 7640} 7641 7642func (*awsRestxml_deserializeOpListTagsForResource) ID() string { 7643 return "OperationDeserializer" 7644} 7645 7646func (m *awsRestxml_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7647 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7648) { 7649 out, metadata, err = next.HandleDeserialize(ctx, in) 7650 if err != nil { 7651 return out, metadata, err 7652 } 7653 7654 response, ok := out.RawResponse.(*smithyhttp.Response) 7655 if !ok { 7656 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7657 } 7658 7659 if response.StatusCode < 200 || response.StatusCode >= 300 { 7660 return out, metadata, awsRestxml_deserializeOpErrorListTagsForResource(response, &metadata) 7661 } 7662 output := &ListTagsForResourceOutput{} 7663 out.Result = output 7664 7665 var buff [1024]byte 7666 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7667 body := io.TeeReader(response.Body, ringBuffer) 7668 rootDecoder := xml.NewDecoder(body) 7669 t, err := smithyxml.FetchRootElement(rootDecoder) 7670 if err == io.EOF { 7671 return out, metadata, nil 7672 } 7673 if err != nil { 7674 var snapshot bytes.Buffer 7675 io.Copy(&snapshot, ringBuffer) 7676 return out, metadata, &smithy.DeserializationError{ 7677 Err: fmt.Errorf("failed to decode response body, %w", err), 7678 Snapshot: snapshot.Bytes(), 7679 } 7680 } 7681 7682 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7683 err = awsRestxml_deserializeOpDocumentListTagsForResourceOutput(&output, decoder) 7684 if err != nil { 7685 var snapshot bytes.Buffer 7686 io.Copy(&snapshot, ringBuffer) 7687 return out, metadata, &smithy.DeserializationError{ 7688 Err: fmt.Errorf("failed to decode response body, %w", err), 7689 Snapshot: snapshot.Bytes(), 7690 } 7691 } 7692 7693 return out, metadata, err 7694} 7695 7696func awsRestxml_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7697 var errorBuffer bytes.Buffer 7698 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7699 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7700 } 7701 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7702 7703 errorCode := "UnknownError" 7704 errorMessage := errorCode 7705 7706 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7707 if err != nil { 7708 return err 7709 } 7710 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7711 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7712 } 7713 if len(errorComponents.Code) != 0 { 7714 errorCode = errorComponents.Code 7715 } 7716 if len(errorComponents.Message) != 0 { 7717 errorMessage = errorComponents.Message 7718 } 7719 errorBody.Seek(0, io.SeekStart) 7720 switch { 7721 case strings.EqualFold("InvalidInput", errorCode): 7722 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7723 7724 case strings.EqualFold("NoSuchHealthCheck", errorCode): 7725 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 7726 7727 case strings.EqualFold("NoSuchHostedZone", errorCode): 7728 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7729 7730 case strings.EqualFold("PriorRequestNotComplete", errorCode): 7731 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 7732 7733 case strings.EqualFold("ThrottlingException", errorCode): 7734 return awsRestxml_deserializeErrorThrottlingException(response, errorBody) 7735 7736 default: 7737 genericError := &smithy.GenericAPIError{ 7738 Code: errorCode, 7739 Message: errorMessage, 7740 } 7741 return genericError 7742 7743 } 7744} 7745 7746func awsRestxml_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error { 7747 if v == nil { 7748 return fmt.Errorf("unexpected nil of type %T", v) 7749 } 7750 var sv *ListTagsForResourceOutput 7751 if *v == nil { 7752 sv = &ListTagsForResourceOutput{} 7753 } else { 7754 sv = *v 7755 } 7756 7757 for { 7758 t, done, err := decoder.Token() 7759 if err != nil { 7760 return err 7761 } 7762 if done { 7763 break 7764 } 7765 originalDecoder := decoder 7766 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7767 switch { 7768 case strings.EqualFold("ResourceTagSet", t.Name.Local): 7769 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7770 if err := awsRestxml_deserializeDocumentResourceTagSet(&sv.ResourceTagSet, nodeDecoder); err != nil { 7771 return err 7772 } 7773 7774 default: 7775 // Do nothing and ignore the unexpected tag element 7776 err = decoder.Decoder.Skip() 7777 if err != nil { 7778 return err 7779 } 7780 7781 } 7782 decoder = originalDecoder 7783 } 7784 *v = sv 7785 return nil 7786} 7787 7788type awsRestxml_deserializeOpListTagsForResources struct { 7789} 7790 7791func (*awsRestxml_deserializeOpListTagsForResources) ID() string { 7792 return "OperationDeserializer" 7793} 7794 7795func (m *awsRestxml_deserializeOpListTagsForResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7796 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7797) { 7798 out, metadata, err = next.HandleDeserialize(ctx, in) 7799 if err != nil { 7800 return out, metadata, err 7801 } 7802 7803 response, ok := out.RawResponse.(*smithyhttp.Response) 7804 if !ok { 7805 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7806 } 7807 7808 if response.StatusCode < 200 || response.StatusCode >= 300 { 7809 return out, metadata, awsRestxml_deserializeOpErrorListTagsForResources(response, &metadata) 7810 } 7811 output := &ListTagsForResourcesOutput{} 7812 out.Result = output 7813 7814 var buff [1024]byte 7815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7816 body := io.TeeReader(response.Body, ringBuffer) 7817 rootDecoder := xml.NewDecoder(body) 7818 t, err := smithyxml.FetchRootElement(rootDecoder) 7819 if err == io.EOF { 7820 return out, metadata, nil 7821 } 7822 if err != nil { 7823 var snapshot bytes.Buffer 7824 io.Copy(&snapshot, ringBuffer) 7825 return out, metadata, &smithy.DeserializationError{ 7826 Err: fmt.Errorf("failed to decode response body, %w", err), 7827 Snapshot: snapshot.Bytes(), 7828 } 7829 } 7830 7831 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7832 err = awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(&output, decoder) 7833 if err != nil { 7834 var snapshot bytes.Buffer 7835 io.Copy(&snapshot, ringBuffer) 7836 return out, metadata, &smithy.DeserializationError{ 7837 Err: fmt.Errorf("failed to decode response body, %w", err), 7838 Snapshot: snapshot.Bytes(), 7839 } 7840 } 7841 7842 return out, metadata, err 7843} 7844 7845func awsRestxml_deserializeOpErrorListTagsForResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7846 var errorBuffer bytes.Buffer 7847 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7848 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7849 } 7850 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7851 7852 errorCode := "UnknownError" 7853 errorMessage := errorCode 7854 7855 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7856 if err != nil { 7857 return err 7858 } 7859 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7860 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7861 } 7862 if len(errorComponents.Code) != 0 { 7863 errorCode = errorComponents.Code 7864 } 7865 if len(errorComponents.Message) != 0 { 7866 errorMessage = errorComponents.Message 7867 } 7868 errorBody.Seek(0, io.SeekStart) 7869 switch { 7870 case strings.EqualFold("InvalidInput", errorCode): 7871 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7872 7873 case strings.EqualFold("NoSuchHealthCheck", errorCode): 7874 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 7875 7876 case strings.EqualFold("NoSuchHostedZone", errorCode): 7877 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7878 7879 case strings.EqualFold("PriorRequestNotComplete", errorCode): 7880 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 7881 7882 case strings.EqualFold("ThrottlingException", errorCode): 7883 return awsRestxml_deserializeErrorThrottlingException(response, errorBody) 7884 7885 default: 7886 genericError := &smithy.GenericAPIError{ 7887 Code: errorCode, 7888 Message: errorMessage, 7889 } 7890 return genericError 7891 7892 } 7893} 7894 7895func awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(v **ListTagsForResourcesOutput, decoder smithyxml.NodeDecoder) error { 7896 if v == nil { 7897 return fmt.Errorf("unexpected nil of type %T", v) 7898 } 7899 var sv *ListTagsForResourcesOutput 7900 if *v == nil { 7901 sv = &ListTagsForResourcesOutput{} 7902 } else { 7903 sv = *v 7904 } 7905 7906 for { 7907 t, done, err := decoder.Token() 7908 if err != nil { 7909 return err 7910 } 7911 if done { 7912 break 7913 } 7914 originalDecoder := decoder 7915 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7916 switch { 7917 case strings.EqualFold("ResourceTagSets", t.Name.Local): 7918 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7919 if err := awsRestxml_deserializeDocumentResourceTagSetList(&sv.ResourceTagSets, nodeDecoder); err != nil { 7920 return err 7921 } 7922 7923 default: 7924 // Do nothing and ignore the unexpected tag element 7925 err = decoder.Decoder.Skip() 7926 if err != nil { 7927 return err 7928 } 7929 7930 } 7931 decoder = originalDecoder 7932 } 7933 *v = sv 7934 return nil 7935} 7936 7937type awsRestxml_deserializeOpListTrafficPolicies struct { 7938} 7939 7940func (*awsRestxml_deserializeOpListTrafficPolicies) ID() string { 7941 return "OperationDeserializer" 7942} 7943 7944func (m *awsRestxml_deserializeOpListTrafficPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7945 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7946) { 7947 out, metadata, err = next.HandleDeserialize(ctx, in) 7948 if err != nil { 7949 return out, metadata, err 7950 } 7951 7952 response, ok := out.RawResponse.(*smithyhttp.Response) 7953 if !ok { 7954 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7955 } 7956 7957 if response.StatusCode < 200 || response.StatusCode >= 300 { 7958 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicies(response, &metadata) 7959 } 7960 output := &ListTrafficPoliciesOutput{} 7961 out.Result = output 7962 7963 var buff [1024]byte 7964 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7965 body := io.TeeReader(response.Body, ringBuffer) 7966 rootDecoder := xml.NewDecoder(body) 7967 t, err := smithyxml.FetchRootElement(rootDecoder) 7968 if err == io.EOF { 7969 return out, metadata, nil 7970 } 7971 if err != nil { 7972 var snapshot bytes.Buffer 7973 io.Copy(&snapshot, ringBuffer) 7974 return out, metadata, &smithy.DeserializationError{ 7975 Err: fmt.Errorf("failed to decode response body, %w", err), 7976 Snapshot: snapshot.Bytes(), 7977 } 7978 } 7979 7980 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7981 err = awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(&output, decoder) 7982 if err != nil { 7983 var snapshot bytes.Buffer 7984 io.Copy(&snapshot, ringBuffer) 7985 return out, metadata, &smithy.DeserializationError{ 7986 Err: fmt.Errorf("failed to decode response body, %w", err), 7987 Snapshot: snapshot.Bytes(), 7988 } 7989 } 7990 7991 return out, metadata, err 7992} 7993 7994func awsRestxml_deserializeOpErrorListTrafficPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7995 var errorBuffer bytes.Buffer 7996 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7997 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7998 } 7999 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8000 8001 errorCode := "UnknownError" 8002 errorMessage := errorCode 8003 8004 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8005 if err != nil { 8006 return err 8007 } 8008 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8009 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8010 } 8011 if len(errorComponents.Code) != 0 { 8012 errorCode = errorComponents.Code 8013 } 8014 if len(errorComponents.Message) != 0 { 8015 errorMessage = errorComponents.Message 8016 } 8017 errorBody.Seek(0, io.SeekStart) 8018 switch { 8019 case strings.EqualFold("InvalidInput", errorCode): 8020 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8021 8022 default: 8023 genericError := &smithy.GenericAPIError{ 8024 Code: errorCode, 8025 Message: errorMessage, 8026 } 8027 return genericError 8028 8029 } 8030} 8031 8032func awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(v **ListTrafficPoliciesOutput, decoder smithyxml.NodeDecoder) error { 8033 if v == nil { 8034 return fmt.Errorf("unexpected nil of type %T", v) 8035 } 8036 var sv *ListTrafficPoliciesOutput 8037 if *v == nil { 8038 sv = &ListTrafficPoliciesOutput{} 8039 } else { 8040 sv = *v 8041 } 8042 8043 for { 8044 t, done, err := decoder.Token() 8045 if err != nil { 8046 return err 8047 } 8048 if done { 8049 break 8050 } 8051 originalDecoder := decoder 8052 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8053 switch { 8054 case strings.EqualFold("IsTruncated", t.Name.Local): 8055 val, err := decoder.Value() 8056 if err != nil { 8057 return err 8058 } 8059 if val == nil { 8060 break 8061 } 8062 { 8063 xtv, err := strconv.ParseBool(string(val)) 8064 if err != nil { 8065 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8066 } 8067 sv.IsTruncated = xtv 8068 } 8069 8070 case strings.EqualFold("MaxItems", t.Name.Local): 8071 val, err := decoder.Value() 8072 if err != nil { 8073 return err 8074 } 8075 if val == nil { 8076 break 8077 } 8078 { 8079 xtv := string(val) 8080 i64, err := strconv.ParseInt(xtv, 10, 64) 8081 if err != nil { 8082 return err 8083 } 8084 sv.MaxItems = ptr.Int32(int32(i64)) 8085 } 8086 8087 case strings.EqualFold("TrafficPolicyIdMarker", t.Name.Local): 8088 val, err := decoder.Value() 8089 if err != nil { 8090 return err 8091 } 8092 if val == nil { 8093 break 8094 } 8095 { 8096 xtv := string(val) 8097 sv.TrafficPolicyIdMarker = ptr.String(xtv) 8098 } 8099 8100 case strings.EqualFold("TrafficPolicySummaries", t.Name.Local): 8101 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8102 if err := awsRestxml_deserializeDocumentTrafficPolicySummaries(&sv.TrafficPolicySummaries, nodeDecoder); err != nil { 8103 return err 8104 } 8105 8106 default: 8107 // Do nothing and ignore the unexpected tag element 8108 err = decoder.Decoder.Skip() 8109 if err != nil { 8110 return err 8111 } 8112 8113 } 8114 decoder = originalDecoder 8115 } 8116 *v = sv 8117 return nil 8118} 8119 8120type awsRestxml_deserializeOpListTrafficPolicyInstances struct { 8121} 8122 8123func (*awsRestxml_deserializeOpListTrafficPolicyInstances) ID() string { 8124 return "OperationDeserializer" 8125} 8126 8127func (m *awsRestxml_deserializeOpListTrafficPolicyInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8128 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8129) { 8130 out, metadata, err = next.HandleDeserialize(ctx, in) 8131 if err != nil { 8132 return out, metadata, err 8133 } 8134 8135 response, ok := out.RawResponse.(*smithyhttp.Response) 8136 if !ok { 8137 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8138 } 8139 8140 if response.StatusCode < 200 || response.StatusCode >= 300 { 8141 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response, &metadata) 8142 } 8143 output := &ListTrafficPolicyInstancesOutput{} 8144 out.Result = output 8145 8146 var buff [1024]byte 8147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8148 body := io.TeeReader(response.Body, ringBuffer) 8149 rootDecoder := xml.NewDecoder(body) 8150 t, err := smithyxml.FetchRootElement(rootDecoder) 8151 if err == io.EOF { 8152 return out, metadata, nil 8153 } 8154 if err != nil { 8155 var snapshot bytes.Buffer 8156 io.Copy(&snapshot, ringBuffer) 8157 return out, metadata, &smithy.DeserializationError{ 8158 Err: fmt.Errorf("failed to decode response body, %w", err), 8159 Snapshot: snapshot.Bytes(), 8160 } 8161 } 8162 8163 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8164 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(&output, decoder) 8165 if err != nil { 8166 var snapshot bytes.Buffer 8167 io.Copy(&snapshot, ringBuffer) 8168 return out, metadata, &smithy.DeserializationError{ 8169 Err: fmt.Errorf("failed to decode response body, %w", err), 8170 Snapshot: snapshot.Bytes(), 8171 } 8172 } 8173 8174 return out, metadata, err 8175} 8176 8177func awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8178 var errorBuffer bytes.Buffer 8179 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8180 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8181 } 8182 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8183 8184 errorCode := "UnknownError" 8185 errorMessage := errorCode 8186 8187 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8188 if err != nil { 8189 return err 8190 } 8191 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8192 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8193 } 8194 if len(errorComponents.Code) != 0 { 8195 errorCode = errorComponents.Code 8196 } 8197 if len(errorComponents.Message) != 0 { 8198 errorMessage = errorComponents.Message 8199 } 8200 errorBody.Seek(0, io.SeekStart) 8201 switch { 8202 case strings.EqualFold("InvalidInput", errorCode): 8203 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8204 8205 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 8206 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 8207 8208 default: 8209 genericError := &smithy.GenericAPIError{ 8210 Code: errorCode, 8211 Message: errorMessage, 8212 } 8213 return genericError 8214 8215 } 8216} 8217 8218func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(v **ListTrafficPolicyInstancesOutput, decoder smithyxml.NodeDecoder) error { 8219 if v == nil { 8220 return fmt.Errorf("unexpected nil of type %T", v) 8221 } 8222 var sv *ListTrafficPolicyInstancesOutput 8223 if *v == nil { 8224 sv = &ListTrafficPolicyInstancesOutput{} 8225 } else { 8226 sv = *v 8227 } 8228 8229 for { 8230 t, done, err := decoder.Token() 8231 if err != nil { 8232 return err 8233 } 8234 if done { 8235 break 8236 } 8237 originalDecoder := decoder 8238 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8239 switch { 8240 case strings.EqualFold("HostedZoneIdMarker", t.Name.Local): 8241 val, err := decoder.Value() 8242 if err != nil { 8243 return err 8244 } 8245 if val == nil { 8246 break 8247 } 8248 { 8249 xtv := string(val) 8250 sv.HostedZoneIdMarker = ptr.String(xtv) 8251 } 8252 8253 case strings.EqualFold("IsTruncated", t.Name.Local): 8254 val, err := decoder.Value() 8255 if err != nil { 8256 return err 8257 } 8258 if val == nil { 8259 break 8260 } 8261 { 8262 xtv, err := strconv.ParseBool(string(val)) 8263 if err != nil { 8264 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8265 } 8266 sv.IsTruncated = xtv 8267 } 8268 8269 case strings.EqualFold("MaxItems", t.Name.Local): 8270 val, err := decoder.Value() 8271 if err != nil { 8272 return err 8273 } 8274 if val == nil { 8275 break 8276 } 8277 { 8278 xtv := string(val) 8279 i64, err := strconv.ParseInt(xtv, 10, 64) 8280 if err != nil { 8281 return err 8282 } 8283 sv.MaxItems = ptr.Int32(int32(i64)) 8284 } 8285 8286 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local): 8287 val, err := decoder.Value() 8288 if err != nil { 8289 return err 8290 } 8291 if val == nil { 8292 break 8293 } 8294 { 8295 xtv := string(val) 8296 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv) 8297 } 8298 8299 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local): 8300 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8301 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil { 8302 return err 8303 } 8304 8305 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local): 8306 val, err := decoder.Value() 8307 if err != nil { 8308 return err 8309 } 8310 if val == nil { 8311 break 8312 } 8313 { 8314 xtv := string(val) 8315 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv) 8316 } 8317 8318 default: 8319 // Do nothing and ignore the unexpected tag element 8320 err = decoder.Decoder.Skip() 8321 if err != nil { 8322 return err 8323 } 8324 8325 } 8326 decoder = originalDecoder 8327 } 8328 *v = sv 8329 return nil 8330} 8331 8332type awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone struct { 8333} 8334 8335func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) ID() string { 8336 return "OperationDeserializer" 8337} 8338 8339func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8340 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8341) { 8342 out, metadata, err = next.HandleDeserialize(ctx, in) 8343 if err != nil { 8344 return out, metadata, err 8345 } 8346 8347 response, ok := out.RawResponse.(*smithyhttp.Response) 8348 if !ok { 8349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8350 } 8351 8352 if response.StatusCode < 200 || response.StatusCode >= 300 { 8353 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response, &metadata) 8354 } 8355 output := &ListTrafficPolicyInstancesByHostedZoneOutput{} 8356 out.Result = output 8357 8358 var buff [1024]byte 8359 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8360 body := io.TeeReader(response.Body, ringBuffer) 8361 rootDecoder := xml.NewDecoder(body) 8362 t, err := smithyxml.FetchRootElement(rootDecoder) 8363 if err == io.EOF { 8364 return out, metadata, nil 8365 } 8366 if err != nil { 8367 var snapshot bytes.Buffer 8368 io.Copy(&snapshot, ringBuffer) 8369 return out, metadata, &smithy.DeserializationError{ 8370 Err: fmt.Errorf("failed to decode response body, %w", err), 8371 Snapshot: snapshot.Bytes(), 8372 } 8373 } 8374 8375 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8376 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(&output, decoder) 8377 if err != nil { 8378 var snapshot bytes.Buffer 8379 io.Copy(&snapshot, ringBuffer) 8380 return out, metadata, &smithy.DeserializationError{ 8381 Err: fmt.Errorf("failed to decode response body, %w", err), 8382 Snapshot: snapshot.Bytes(), 8383 } 8384 } 8385 8386 return out, metadata, err 8387} 8388 8389func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8390 var errorBuffer bytes.Buffer 8391 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8392 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8393 } 8394 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8395 8396 errorCode := "UnknownError" 8397 errorMessage := errorCode 8398 8399 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8400 if err != nil { 8401 return err 8402 } 8403 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8404 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8405 } 8406 if len(errorComponents.Code) != 0 { 8407 errorCode = errorComponents.Code 8408 } 8409 if len(errorComponents.Message) != 0 { 8410 errorMessage = errorComponents.Message 8411 } 8412 errorBody.Seek(0, io.SeekStart) 8413 switch { 8414 case strings.EqualFold("InvalidInput", errorCode): 8415 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8416 8417 case strings.EqualFold("NoSuchHostedZone", errorCode): 8418 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 8419 8420 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 8421 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 8422 8423 default: 8424 genericError := &smithy.GenericAPIError{ 8425 Code: errorCode, 8426 Message: errorMessage, 8427 } 8428 return genericError 8429 8430 } 8431} 8432 8433func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(v **ListTrafficPolicyInstancesByHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 8434 if v == nil { 8435 return fmt.Errorf("unexpected nil of type %T", v) 8436 } 8437 var sv *ListTrafficPolicyInstancesByHostedZoneOutput 8438 if *v == nil { 8439 sv = &ListTrafficPolicyInstancesByHostedZoneOutput{} 8440 } else { 8441 sv = *v 8442 } 8443 8444 for { 8445 t, done, err := decoder.Token() 8446 if err != nil { 8447 return err 8448 } 8449 if done { 8450 break 8451 } 8452 originalDecoder := decoder 8453 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8454 switch { 8455 case strings.EqualFold("IsTruncated", t.Name.Local): 8456 val, err := decoder.Value() 8457 if err != nil { 8458 return err 8459 } 8460 if val == nil { 8461 break 8462 } 8463 { 8464 xtv, err := strconv.ParseBool(string(val)) 8465 if err != nil { 8466 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8467 } 8468 sv.IsTruncated = xtv 8469 } 8470 8471 case strings.EqualFold("MaxItems", t.Name.Local): 8472 val, err := decoder.Value() 8473 if err != nil { 8474 return err 8475 } 8476 if val == nil { 8477 break 8478 } 8479 { 8480 xtv := string(val) 8481 i64, err := strconv.ParseInt(xtv, 10, 64) 8482 if err != nil { 8483 return err 8484 } 8485 sv.MaxItems = ptr.Int32(int32(i64)) 8486 } 8487 8488 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local): 8489 val, err := decoder.Value() 8490 if err != nil { 8491 return err 8492 } 8493 if val == nil { 8494 break 8495 } 8496 { 8497 xtv := string(val) 8498 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv) 8499 } 8500 8501 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local): 8502 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8503 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil { 8504 return err 8505 } 8506 8507 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local): 8508 val, err := decoder.Value() 8509 if err != nil { 8510 return err 8511 } 8512 if val == nil { 8513 break 8514 } 8515 { 8516 xtv := string(val) 8517 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv) 8518 } 8519 8520 default: 8521 // Do nothing and ignore the unexpected tag element 8522 err = decoder.Decoder.Skip() 8523 if err != nil { 8524 return err 8525 } 8526 8527 } 8528 decoder = originalDecoder 8529 } 8530 *v = sv 8531 return nil 8532} 8533 8534type awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy struct { 8535} 8536 8537func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) ID() string { 8538 return "OperationDeserializer" 8539} 8540 8541func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8542 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8543) { 8544 out, metadata, err = next.HandleDeserialize(ctx, in) 8545 if err != nil { 8546 return out, metadata, err 8547 } 8548 8549 response, ok := out.RawResponse.(*smithyhttp.Response) 8550 if !ok { 8551 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8552 } 8553 8554 if response.StatusCode < 200 || response.StatusCode >= 300 { 8555 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response, &metadata) 8556 } 8557 output := &ListTrafficPolicyInstancesByPolicyOutput{} 8558 out.Result = output 8559 8560 var buff [1024]byte 8561 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8562 body := io.TeeReader(response.Body, ringBuffer) 8563 rootDecoder := xml.NewDecoder(body) 8564 t, err := smithyxml.FetchRootElement(rootDecoder) 8565 if err == io.EOF { 8566 return out, metadata, nil 8567 } 8568 if err != nil { 8569 var snapshot bytes.Buffer 8570 io.Copy(&snapshot, ringBuffer) 8571 return out, metadata, &smithy.DeserializationError{ 8572 Err: fmt.Errorf("failed to decode response body, %w", err), 8573 Snapshot: snapshot.Bytes(), 8574 } 8575 } 8576 8577 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8578 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(&output, decoder) 8579 if err != nil { 8580 var snapshot bytes.Buffer 8581 io.Copy(&snapshot, ringBuffer) 8582 return out, metadata, &smithy.DeserializationError{ 8583 Err: fmt.Errorf("failed to decode response body, %w", err), 8584 Snapshot: snapshot.Bytes(), 8585 } 8586 } 8587 8588 return out, metadata, err 8589} 8590 8591func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8592 var errorBuffer bytes.Buffer 8593 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8594 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8595 } 8596 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8597 8598 errorCode := "UnknownError" 8599 errorMessage := errorCode 8600 8601 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8602 if err != nil { 8603 return err 8604 } 8605 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8606 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8607 } 8608 if len(errorComponents.Code) != 0 { 8609 errorCode = errorComponents.Code 8610 } 8611 if len(errorComponents.Message) != 0 { 8612 errorMessage = errorComponents.Message 8613 } 8614 errorBody.Seek(0, io.SeekStart) 8615 switch { 8616 case strings.EqualFold("InvalidInput", errorCode): 8617 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8618 8619 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 8620 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 8621 8622 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 8623 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 8624 8625 default: 8626 genericError := &smithy.GenericAPIError{ 8627 Code: errorCode, 8628 Message: errorMessage, 8629 } 8630 return genericError 8631 8632 } 8633} 8634 8635func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(v **ListTrafficPolicyInstancesByPolicyOutput, decoder smithyxml.NodeDecoder) error { 8636 if v == nil { 8637 return fmt.Errorf("unexpected nil of type %T", v) 8638 } 8639 var sv *ListTrafficPolicyInstancesByPolicyOutput 8640 if *v == nil { 8641 sv = &ListTrafficPolicyInstancesByPolicyOutput{} 8642 } else { 8643 sv = *v 8644 } 8645 8646 for { 8647 t, done, err := decoder.Token() 8648 if err != nil { 8649 return err 8650 } 8651 if done { 8652 break 8653 } 8654 originalDecoder := decoder 8655 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8656 switch { 8657 case strings.EqualFold("HostedZoneIdMarker", t.Name.Local): 8658 val, err := decoder.Value() 8659 if err != nil { 8660 return err 8661 } 8662 if val == nil { 8663 break 8664 } 8665 { 8666 xtv := string(val) 8667 sv.HostedZoneIdMarker = ptr.String(xtv) 8668 } 8669 8670 case strings.EqualFold("IsTruncated", t.Name.Local): 8671 val, err := decoder.Value() 8672 if err != nil { 8673 return err 8674 } 8675 if val == nil { 8676 break 8677 } 8678 { 8679 xtv, err := strconv.ParseBool(string(val)) 8680 if err != nil { 8681 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8682 } 8683 sv.IsTruncated = xtv 8684 } 8685 8686 case strings.EqualFold("MaxItems", t.Name.Local): 8687 val, err := decoder.Value() 8688 if err != nil { 8689 return err 8690 } 8691 if val == nil { 8692 break 8693 } 8694 { 8695 xtv := string(val) 8696 i64, err := strconv.ParseInt(xtv, 10, 64) 8697 if err != nil { 8698 return err 8699 } 8700 sv.MaxItems = ptr.Int32(int32(i64)) 8701 } 8702 8703 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local): 8704 val, err := decoder.Value() 8705 if err != nil { 8706 return err 8707 } 8708 if val == nil { 8709 break 8710 } 8711 { 8712 xtv := string(val) 8713 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv) 8714 } 8715 8716 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local): 8717 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8718 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil { 8719 return err 8720 } 8721 8722 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local): 8723 val, err := decoder.Value() 8724 if err != nil { 8725 return err 8726 } 8727 if val == nil { 8728 break 8729 } 8730 { 8731 xtv := string(val) 8732 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv) 8733 } 8734 8735 default: 8736 // Do nothing and ignore the unexpected tag element 8737 err = decoder.Decoder.Skip() 8738 if err != nil { 8739 return err 8740 } 8741 8742 } 8743 decoder = originalDecoder 8744 } 8745 *v = sv 8746 return nil 8747} 8748 8749type awsRestxml_deserializeOpListTrafficPolicyVersions struct { 8750} 8751 8752func (*awsRestxml_deserializeOpListTrafficPolicyVersions) ID() string { 8753 return "OperationDeserializer" 8754} 8755 8756func (m *awsRestxml_deserializeOpListTrafficPolicyVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8757 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8758) { 8759 out, metadata, err = next.HandleDeserialize(ctx, in) 8760 if err != nil { 8761 return out, metadata, err 8762 } 8763 8764 response, ok := out.RawResponse.(*smithyhttp.Response) 8765 if !ok { 8766 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8767 } 8768 8769 if response.StatusCode < 200 || response.StatusCode >= 300 { 8770 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response, &metadata) 8771 } 8772 output := &ListTrafficPolicyVersionsOutput{} 8773 out.Result = output 8774 8775 var buff [1024]byte 8776 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8777 body := io.TeeReader(response.Body, ringBuffer) 8778 rootDecoder := xml.NewDecoder(body) 8779 t, err := smithyxml.FetchRootElement(rootDecoder) 8780 if err == io.EOF { 8781 return out, metadata, nil 8782 } 8783 if err != nil { 8784 var snapshot bytes.Buffer 8785 io.Copy(&snapshot, ringBuffer) 8786 return out, metadata, &smithy.DeserializationError{ 8787 Err: fmt.Errorf("failed to decode response body, %w", err), 8788 Snapshot: snapshot.Bytes(), 8789 } 8790 } 8791 8792 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8793 err = awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(&output, decoder) 8794 if err != nil { 8795 var snapshot bytes.Buffer 8796 io.Copy(&snapshot, ringBuffer) 8797 return out, metadata, &smithy.DeserializationError{ 8798 Err: fmt.Errorf("failed to decode response body, %w", err), 8799 Snapshot: snapshot.Bytes(), 8800 } 8801 } 8802 8803 return out, metadata, err 8804} 8805 8806func awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8807 var errorBuffer bytes.Buffer 8808 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8809 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8810 } 8811 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8812 8813 errorCode := "UnknownError" 8814 errorMessage := errorCode 8815 8816 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8817 if err != nil { 8818 return err 8819 } 8820 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8821 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8822 } 8823 if len(errorComponents.Code) != 0 { 8824 errorCode = errorComponents.Code 8825 } 8826 if len(errorComponents.Message) != 0 { 8827 errorMessage = errorComponents.Message 8828 } 8829 errorBody.Seek(0, io.SeekStart) 8830 switch { 8831 case strings.EqualFold("InvalidInput", errorCode): 8832 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8833 8834 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 8835 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 8836 8837 default: 8838 genericError := &smithy.GenericAPIError{ 8839 Code: errorCode, 8840 Message: errorMessage, 8841 } 8842 return genericError 8843 8844 } 8845} 8846 8847func awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(v **ListTrafficPolicyVersionsOutput, decoder smithyxml.NodeDecoder) error { 8848 if v == nil { 8849 return fmt.Errorf("unexpected nil of type %T", v) 8850 } 8851 var sv *ListTrafficPolicyVersionsOutput 8852 if *v == nil { 8853 sv = &ListTrafficPolicyVersionsOutput{} 8854 } else { 8855 sv = *v 8856 } 8857 8858 for { 8859 t, done, err := decoder.Token() 8860 if err != nil { 8861 return err 8862 } 8863 if done { 8864 break 8865 } 8866 originalDecoder := decoder 8867 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8868 switch { 8869 case strings.EqualFold("IsTruncated", t.Name.Local): 8870 val, err := decoder.Value() 8871 if err != nil { 8872 return err 8873 } 8874 if val == nil { 8875 break 8876 } 8877 { 8878 xtv, err := strconv.ParseBool(string(val)) 8879 if err != nil { 8880 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8881 } 8882 sv.IsTruncated = xtv 8883 } 8884 8885 case strings.EqualFold("MaxItems", t.Name.Local): 8886 val, err := decoder.Value() 8887 if err != nil { 8888 return err 8889 } 8890 if val == nil { 8891 break 8892 } 8893 { 8894 xtv := string(val) 8895 i64, err := strconv.ParseInt(xtv, 10, 64) 8896 if err != nil { 8897 return err 8898 } 8899 sv.MaxItems = ptr.Int32(int32(i64)) 8900 } 8901 8902 case strings.EqualFold("TrafficPolicies", t.Name.Local): 8903 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8904 if err := awsRestxml_deserializeDocumentTrafficPolicies(&sv.TrafficPolicies, nodeDecoder); err != nil { 8905 return err 8906 } 8907 8908 case strings.EqualFold("TrafficPolicyVersionMarker", t.Name.Local): 8909 val, err := decoder.Value() 8910 if err != nil { 8911 return err 8912 } 8913 if val == nil { 8914 break 8915 } 8916 { 8917 xtv := string(val) 8918 sv.TrafficPolicyVersionMarker = ptr.String(xtv) 8919 } 8920 8921 default: 8922 // Do nothing and ignore the unexpected tag element 8923 err = decoder.Decoder.Skip() 8924 if err != nil { 8925 return err 8926 } 8927 8928 } 8929 decoder = originalDecoder 8930 } 8931 *v = sv 8932 return nil 8933} 8934 8935type awsRestxml_deserializeOpListVPCAssociationAuthorizations struct { 8936} 8937 8938func (*awsRestxml_deserializeOpListVPCAssociationAuthorizations) ID() string { 8939 return "OperationDeserializer" 8940} 8941 8942func (m *awsRestxml_deserializeOpListVPCAssociationAuthorizations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8943 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8944) { 8945 out, metadata, err = next.HandleDeserialize(ctx, in) 8946 if err != nil { 8947 return out, metadata, err 8948 } 8949 8950 response, ok := out.RawResponse.(*smithyhttp.Response) 8951 if !ok { 8952 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8953 } 8954 8955 if response.StatusCode < 200 || response.StatusCode >= 300 { 8956 return out, metadata, awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response, &metadata) 8957 } 8958 output := &ListVPCAssociationAuthorizationsOutput{} 8959 out.Result = output 8960 8961 var buff [1024]byte 8962 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8963 body := io.TeeReader(response.Body, ringBuffer) 8964 rootDecoder := xml.NewDecoder(body) 8965 t, err := smithyxml.FetchRootElement(rootDecoder) 8966 if err == io.EOF { 8967 return out, metadata, nil 8968 } 8969 if err != nil { 8970 var snapshot bytes.Buffer 8971 io.Copy(&snapshot, ringBuffer) 8972 return out, metadata, &smithy.DeserializationError{ 8973 Err: fmt.Errorf("failed to decode response body, %w", err), 8974 Snapshot: snapshot.Bytes(), 8975 } 8976 } 8977 8978 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8979 err = awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(&output, decoder) 8980 if err != nil { 8981 var snapshot bytes.Buffer 8982 io.Copy(&snapshot, ringBuffer) 8983 return out, metadata, &smithy.DeserializationError{ 8984 Err: fmt.Errorf("failed to decode response body, %w", err), 8985 Snapshot: snapshot.Bytes(), 8986 } 8987 } 8988 8989 return out, metadata, err 8990} 8991 8992func awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8993 var errorBuffer bytes.Buffer 8994 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8995 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8996 } 8997 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8998 8999 errorCode := "UnknownError" 9000 errorMessage := errorCode 9001 9002 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9003 if err != nil { 9004 return err 9005 } 9006 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9007 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9008 } 9009 if len(errorComponents.Code) != 0 { 9010 errorCode = errorComponents.Code 9011 } 9012 if len(errorComponents.Message) != 0 { 9013 errorMessage = errorComponents.Message 9014 } 9015 errorBody.Seek(0, io.SeekStart) 9016 switch { 9017 case strings.EqualFold("InvalidInput", errorCode): 9018 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9019 9020 case strings.EqualFold("InvalidPaginationToken", errorCode): 9021 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody) 9022 9023 case strings.EqualFold("NoSuchHostedZone", errorCode): 9024 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 9025 9026 default: 9027 genericError := &smithy.GenericAPIError{ 9028 Code: errorCode, 9029 Message: errorMessage, 9030 } 9031 return genericError 9032 9033 } 9034} 9035 9036func awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(v **ListVPCAssociationAuthorizationsOutput, decoder smithyxml.NodeDecoder) error { 9037 if v == nil { 9038 return fmt.Errorf("unexpected nil of type %T", v) 9039 } 9040 var sv *ListVPCAssociationAuthorizationsOutput 9041 if *v == nil { 9042 sv = &ListVPCAssociationAuthorizationsOutput{} 9043 } else { 9044 sv = *v 9045 } 9046 9047 for { 9048 t, done, err := decoder.Token() 9049 if err != nil { 9050 return err 9051 } 9052 if done { 9053 break 9054 } 9055 originalDecoder := decoder 9056 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9057 switch { 9058 case strings.EqualFold("HostedZoneId", t.Name.Local): 9059 val, err := decoder.Value() 9060 if err != nil { 9061 return err 9062 } 9063 if val == nil { 9064 break 9065 } 9066 { 9067 xtv := string(val) 9068 sv.HostedZoneId = ptr.String(xtv) 9069 } 9070 9071 case strings.EqualFold("NextToken", t.Name.Local): 9072 val, err := decoder.Value() 9073 if err != nil { 9074 return err 9075 } 9076 if val == nil { 9077 break 9078 } 9079 { 9080 xtv := string(val) 9081 sv.NextToken = ptr.String(xtv) 9082 } 9083 9084 case strings.EqualFold("VPCs", t.Name.Local): 9085 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9086 if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil { 9087 return err 9088 } 9089 9090 default: 9091 // Do nothing and ignore the unexpected tag element 9092 err = decoder.Decoder.Skip() 9093 if err != nil { 9094 return err 9095 } 9096 9097 } 9098 decoder = originalDecoder 9099 } 9100 *v = sv 9101 return nil 9102} 9103 9104type awsRestxml_deserializeOpTestDNSAnswer struct { 9105} 9106 9107func (*awsRestxml_deserializeOpTestDNSAnswer) ID() string { 9108 return "OperationDeserializer" 9109} 9110 9111func (m *awsRestxml_deserializeOpTestDNSAnswer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9112 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9113) { 9114 out, metadata, err = next.HandleDeserialize(ctx, in) 9115 if err != nil { 9116 return out, metadata, err 9117 } 9118 9119 response, ok := out.RawResponse.(*smithyhttp.Response) 9120 if !ok { 9121 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9122 } 9123 9124 if response.StatusCode < 200 || response.StatusCode >= 300 { 9125 return out, metadata, awsRestxml_deserializeOpErrorTestDNSAnswer(response, &metadata) 9126 } 9127 output := &TestDNSAnswerOutput{} 9128 out.Result = output 9129 9130 var buff [1024]byte 9131 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9132 body := io.TeeReader(response.Body, ringBuffer) 9133 rootDecoder := xml.NewDecoder(body) 9134 t, err := smithyxml.FetchRootElement(rootDecoder) 9135 if err == io.EOF { 9136 return out, metadata, nil 9137 } 9138 if err != nil { 9139 var snapshot bytes.Buffer 9140 io.Copy(&snapshot, ringBuffer) 9141 return out, metadata, &smithy.DeserializationError{ 9142 Err: fmt.Errorf("failed to decode response body, %w", err), 9143 Snapshot: snapshot.Bytes(), 9144 } 9145 } 9146 9147 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9148 err = awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(&output, decoder) 9149 if err != nil { 9150 var snapshot bytes.Buffer 9151 io.Copy(&snapshot, ringBuffer) 9152 return out, metadata, &smithy.DeserializationError{ 9153 Err: fmt.Errorf("failed to decode response body, %w", err), 9154 Snapshot: snapshot.Bytes(), 9155 } 9156 } 9157 9158 return out, metadata, err 9159} 9160 9161func awsRestxml_deserializeOpErrorTestDNSAnswer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9162 var errorBuffer bytes.Buffer 9163 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9164 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9165 } 9166 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9167 9168 errorCode := "UnknownError" 9169 errorMessage := errorCode 9170 9171 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9172 if err != nil { 9173 return err 9174 } 9175 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9176 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9177 } 9178 if len(errorComponents.Code) != 0 { 9179 errorCode = errorComponents.Code 9180 } 9181 if len(errorComponents.Message) != 0 { 9182 errorMessage = errorComponents.Message 9183 } 9184 errorBody.Seek(0, io.SeekStart) 9185 switch { 9186 case strings.EqualFold("InvalidInput", errorCode): 9187 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9188 9189 case strings.EqualFold("NoSuchHostedZone", errorCode): 9190 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 9191 9192 default: 9193 genericError := &smithy.GenericAPIError{ 9194 Code: errorCode, 9195 Message: errorMessage, 9196 } 9197 return genericError 9198 9199 } 9200} 9201 9202func awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(v **TestDNSAnswerOutput, decoder smithyxml.NodeDecoder) error { 9203 if v == nil { 9204 return fmt.Errorf("unexpected nil of type %T", v) 9205 } 9206 var sv *TestDNSAnswerOutput 9207 if *v == nil { 9208 sv = &TestDNSAnswerOutput{} 9209 } else { 9210 sv = *v 9211 } 9212 9213 for { 9214 t, done, err := decoder.Token() 9215 if err != nil { 9216 return err 9217 } 9218 if done { 9219 break 9220 } 9221 originalDecoder := decoder 9222 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9223 switch { 9224 case strings.EqualFold("Nameserver", t.Name.Local): 9225 val, err := decoder.Value() 9226 if err != nil { 9227 return err 9228 } 9229 if val == nil { 9230 break 9231 } 9232 { 9233 xtv := string(val) 9234 sv.Nameserver = ptr.String(xtv) 9235 } 9236 9237 case strings.EqualFold("Protocol", t.Name.Local): 9238 val, err := decoder.Value() 9239 if err != nil { 9240 return err 9241 } 9242 if val == nil { 9243 break 9244 } 9245 { 9246 xtv := string(val) 9247 sv.Protocol = ptr.String(xtv) 9248 } 9249 9250 case strings.EqualFold("RecordData", t.Name.Local): 9251 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9252 if err := awsRestxml_deserializeDocumentRecordData(&sv.RecordData, nodeDecoder); err != nil { 9253 return err 9254 } 9255 9256 case strings.EqualFold("RecordName", t.Name.Local): 9257 val, err := decoder.Value() 9258 if err != nil { 9259 return err 9260 } 9261 if val == nil { 9262 break 9263 } 9264 { 9265 xtv := string(val) 9266 sv.RecordName = ptr.String(xtv) 9267 } 9268 9269 case strings.EqualFold("RecordType", t.Name.Local): 9270 val, err := decoder.Value() 9271 if err != nil { 9272 return err 9273 } 9274 if val == nil { 9275 break 9276 } 9277 { 9278 xtv := string(val) 9279 sv.RecordType = types.RRType(xtv) 9280 } 9281 9282 case strings.EqualFold("ResponseCode", t.Name.Local): 9283 val, err := decoder.Value() 9284 if err != nil { 9285 return err 9286 } 9287 if val == nil { 9288 break 9289 } 9290 { 9291 xtv := string(val) 9292 sv.ResponseCode = ptr.String(xtv) 9293 } 9294 9295 default: 9296 // Do nothing and ignore the unexpected tag element 9297 err = decoder.Decoder.Skip() 9298 if err != nil { 9299 return err 9300 } 9301 9302 } 9303 decoder = originalDecoder 9304 } 9305 *v = sv 9306 return nil 9307} 9308 9309type awsRestxml_deserializeOpUpdateHealthCheck struct { 9310} 9311 9312func (*awsRestxml_deserializeOpUpdateHealthCheck) ID() string { 9313 return "OperationDeserializer" 9314} 9315 9316func (m *awsRestxml_deserializeOpUpdateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9317 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9318) { 9319 out, metadata, err = next.HandleDeserialize(ctx, in) 9320 if err != nil { 9321 return out, metadata, err 9322 } 9323 9324 response, ok := out.RawResponse.(*smithyhttp.Response) 9325 if !ok { 9326 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9327 } 9328 9329 if response.StatusCode < 200 || response.StatusCode >= 300 { 9330 return out, metadata, awsRestxml_deserializeOpErrorUpdateHealthCheck(response, &metadata) 9331 } 9332 output := &UpdateHealthCheckOutput{} 9333 out.Result = output 9334 9335 var buff [1024]byte 9336 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9337 body := io.TeeReader(response.Body, ringBuffer) 9338 rootDecoder := xml.NewDecoder(body) 9339 t, err := smithyxml.FetchRootElement(rootDecoder) 9340 if err == io.EOF { 9341 return out, metadata, nil 9342 } 9343 if err != nil { 9344 var snapshot bytes.Buffer 9345 io.Copy(&snapshot, ringBuffer) 9346 return out, metadata, &smithy.DeserializationError{ 9347 Err: fmt.Errorf("failed to decode response body, %w", err), 9348 Snapshot: snapshot.Bytes(), 9349 } 9350 } 9351 9352 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9353 err = awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(&output, decoder) 9354 if err != nil { 9355 var snapshot bytes.Buffer 9356 io.Copy(&snapshot, ringBuffer) 9357 return out, metadata, &smithy.DeserializationError{ 9358 Err: fmt.Errorf("failed to decode response body, %w", err), 9359 Snapshot: snapshot.Bytes(), 9360 } 9361 } 9362 9363 return out, metadata, err 9364} 9365 9366func awsRestxml_deserializeOpErrorUpdateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9367 var errorBuffer bytes.Buffer 9368 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9369 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9370 } 9371 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9372 9373 errorCode := "UnknownError" 9374 errorMessage := errorCode 9375 9376 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9377 if err != nil { 9378 return err 9379 } 9380 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9381 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9382 } 9383 if len(errorComponents.Code) != 0 { 9384 errorCode = errorComponents.Code 9385 } 9386 if len(errorComponents.Message) != 0 { 9387 errorMessage = errorComponents.Message 9388 } 9389 errorBody.Seek(0, io.SeekStart) 9390 switch { 9391 case strings.EqualFold("HealthCheckVersionMismatch", errorCode): 9392 return awsRestxml_deserializeErrorHealthCheckVersionMismatch(response, errorBody) 9393 9394 case strings.EqualFold("InvalidInput", errorCode): 9395 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9396 9397 case strings.EqualFold("NoSuchHealthCheck", errorCode): 9398 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 9399 9400 default: 9401 genericError := &smithy.GenericAPIError{ 9402 Code: errorCode, 9403 Message: errorMessage, 9404 } 9405 return genericError 9406 9407 } 9408} 9409 9410func awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(v **UpdateHealthCheckOutput, decoder smithyxml.NodeDecoder) error { 9411 if v == nil { 9412 return fmt.Errorf("unexpected nil of type %T", v) 9413 } 9414 var sv *UpdateHealthCheckOutput 9415 if *v == nil { 9416 sv = &UpdateHealthCheckOutput{} 9417 } else { 9418 sv = *v 9419 } 9420 9421 for { 9422 t, done, err := decoder.Token() 9423 if err != nil { 9424 return err 9425 } 9426 if done { 9427 break 9428 } 9429 originalDecoder := decoder 9430 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9431 switch { 9432 case strings.EqualFold("HealthCheck", t.Name.Local): 9433 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9434 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil { 9435 return err 9436 } 9437 9438 default: 9439 // Do nothing and ignore the unexpected tag element 9440 err = decoder.Decoder.Skip() 9441 if err != nil { 9442 return err 9443 } 9444 9445 } 9446 decoder = originalDecoder 9447 } 9448 *v = sv 9449 return nil 9450} 9451 9452type awsRestxml_deserializeOpUpdateHostedZoneComment struct { 9453} 9454 9455func (*awsRestxml_deserializeOpUpdateHostedZoneComment) ID() string { 9456 return "OperationDeserializer" 9457} 9458 9459func (m *awsRestxml_deserializeOpUpdateHostedZoneComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9460 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9461) { 9462 out, metadata, err = next.HandleDeserialize(ctx, in) 9463 if err != nil { 9464 return out, metadata, err 9465 } 9466 9467 response, ok := out.RawResponse.(*smithyhttp.Response) 9468 if !ok { 9469 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9470 } 9471 9472 if response.StatusCode < 200 || response.StatusCode >= 300 { 9473 return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response, &metadata) 9474 } 9475 output := &UpdateHostedZoneCommentOutput{} 9476 out.Result = output 9477 9478 var buff [1024]byte 9479 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9480 body := io.TeeReader(response.Body, ringBuffer) 9481 rootDecoder := xml.NewDecoder(body) 9482 t, err := smithyxml.FetchRootElement(rootDecoder) 9483 if err == io.EOF { 9484 return out, metadata, nil 9485 } 9486 if err != nil { 9487 var snapshot bytes.Buffer 9488 io.Copy(&snapshot, ringBuffer) 9489 return out, metadata, &smithy.DeserializationError{ 9490 Err: fmt.Errorf("failed to decode response body, %w", err), 9491 Snapshot: snapshot.Bytes(), 9492 } 9493 } 9494 9495 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9496 err = awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(&output, decoder) 9497 if err != nil { 9498 var snapshot bytes.Buffer 9499 io.Copy(&snapshot, ringBuffer) 9500 return out, metadata, &smithy.DeserializationError{ 9501 Err: fmt.Errorf("failed to decode response body, %w", err), 9502 Snapshot: snapshot.Bytes(), 9503 } 9504 } 9505 9506 return out, metadata, err 9507} 9508 9509func awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9510 var errorBuffer bytes.Buffer 9511 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9512 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9513 } 9514 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9515 9516 errorCode := "UnknownError" 9517 errorMessage := errorCode 9518 9519 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9520 if err != nil { 9521 return err 9522 } 9523 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9524 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9525 } 9526 if len(errorComponents.Code) != 0 { 9527 errorCode = errorComponents.Code 9528 } 9529 if len(errorComponents.Message) != 0 { 9530 errorMessage = errorComponents.Message 9531 } 9532 errorBody.Seek(0, io.SeekStart) 9533 switch { 9534 case strings.EqualFold("InvalidInput", errorCode): 9535 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9536 9537 case strings.EqualFold("NoSuchHostedZone", errorCode): 9538 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 9539 9540 default: 9541 genericError := &smithy.GenericAPIError{ 9542 Code: errorCode, 9543 Message: errorMessage, 9544 } 9545 return genericError 9546 9547 } 9548} 9549 9550func awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(v **UpdateHostedZoneCommentOutput, decoder smithyxml.NodeDecoder) error { 9551 if v == nil { 9552 return fmt.Errorf("unexpected nil of type %T", v) 9553 } 9554 var sv *UpdateHostedZoneCommentOutput 9555 if *v == nil { 9556 sv = &UpdateHostedZoneCommentOutput{} 9557 } else { 9558 sv = *v 9559 } 9560 9561 for { 9562 t, done, err := decoder.Token() 9563 if err != nil { 9564 return err 9565 } 9566 if done { 9567 break 9568 } 9569 originalDecoder := decoder 9570 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9571 switch { 9572 case strings.EqualFold("HostedZone", t.Name.Local): 9573 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9574 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil { 9575 return err 9576 } 9577 9578 default: 9579 // Do nothing and ignore the unexpected tag element 9580 err = decoder.Decoder.Skip() 9581 if err != nil { 9582 return err 9583 } 9584 9585 } 9586 decoder = originalDecoder 9587 } 9588 *v = sv 9589 return nil 9590} 9591 9592type awsRestxml_deserializeOpUpdateTrafficPolicyComment struct { 9593} 9594 9595func (*awsRestxml_deserializeOpUpdateTrafficPolicyComment) ID() string { 9596 return "OperationDeserializer" 9597} 9598 9599func (m *awsRestxml_deserializeOpUpdateTrafficPolicyComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9600 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9601) { 9602 out, metadata, err = next.HandleDeserialize(ctx, in) 9603 if err != nil { 9604 return out, metadata, err 9605 } 9606 9607 response, ok := out.RawResponse.(*smithyhttp.Response) 9608 if !ok { 9609 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9610 } 9611 9612 if response.StatusCode < 200 || response.StatusCode >= 300 { 9613 return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response, &metadata) 9614 } 9615 output := &UpdateTrafficPolicyCommentOutput{} 9616 out.Result = output 9617 9618 var buff [1024]byte 9619 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9620 body := io.TeeReader(response.Body, ringBuffer) 9621 rootDecoder := xml.NewDecoder(body) 9622 t, err := smithyxml.FetchRootElement(rootDecoder) 9623 if err == io.EOF { 9624 return out, metadata, nil 9625 } 9626 if err != nil { 9627 var snapshot bytes.Buffer 9628 io.Copy(&snapshot, ringBuffer) 9629 return out, metadata, &smithy.DeserializationError{ 9630 Err: fmt.Errorf("failed to decode response body, %w", err), 9631 Snapshot: snapshot.Bytes(), 9632 } 9633 } 9634 9635 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9636 err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(&output, decoder) 9637 if err != nil { 9638 var snapshot bytes.Buffer 9639 io.Copy(&snapshot, ringBuffer) 9640 return out, metadata, &smithy.DeserializationError{ 9641 Err: fmt.Errorf("failed to decode response body, %w", err), 9642 Snapshot: snapshot.Bytes(), 9643 } 9644 } 9645 9646 return out, metadata, err 9647} 9648 9649func awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9650 var errorBuffer bytes.Buffer 9651 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9652 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9653 } 9654 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9655 9656 errorCode := "UnknownError" 9657 errorMessage := errorCode 9658 9659 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9660 if err != nil { 9661 return err 9662 } 9663 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9664 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9665 } 9666 if len(errorComponents.Code) != 0 { 9667 errorCode = errorComponents.Code 9668 } 9669 if len(errorComponents.Message) != 0 { 9670 errorMessage = errorComponents.Message 9671 } 9672 errorBody.Seek(0, io.SeekStart) 9673 switch { 9674 case strings.EqualFold("ConcurrentModification", errorCode): 9675 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 9676 9677 case strings.EqualFold("InvalidInput", errorCode): 9678 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9679 9680 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 9681 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 9682 9683 default: 9684 genericError := &smithy.GenericAPIError{ 9685 Code: errorCode, 9686 Message: errorMessage, 9687 } 9688 return genericError 9689 9690 } 9691} 9692 9693func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(v **UpdateTrafficPolicyCommentOutput, decoder smithyxml.NodeDecoder) error { 9694 if v == nil { 9695 return fmt.Errorf("unexpected nil of type %T", v) 9696 } 9697 var sv *UpdateTrafficPolicyCommentOutput 9698 if *v == nil { 9699 sv = &UpdateTrafficPolicyCommentOutput{} 9700 } else { 9701 sv = *v 9702 } 9703 9704 for { 9705 t, done, err := decoder.Token() 9706 if err != nil { 9707 return err 9708 } 9709 if done { 9710 break 9711 } 9712 originalDecoder := decoder 9713 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9714 switch { 9715 case strings.EqualFold("TrafficPolicy", t.Name.Local): 9716 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9717 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 9718 return err 9719 } 9720 9721 default: 9722 // Do nothing and ignore the unexpected tag element 9723 err = decoder.Decoder.Skip() 9724 if err != nil { 9725 return err 9726 } 9727 9728 } 9729 decoder = originalDecoder 9730 } 9731 *v = sv 9732 return nil 9733} 9734 9735type awsRestxml_deserializeOpUpdateTrafficPolicyInstance struct { 9736} 9737 9738func (*awsRestxml_deserializeOpUpdateTrafficPolicyInstance) ID() string { 9739 return "OperationDeserializer" 9740} 9741 9742func (m *awsRestxml_deserializeOpUpdateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9743 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9744) { 9745 out, metadata, err = next.HandleDeserialize(ctx, in) 9746 if err != nil { 9747 return out, metadata, err 9748 } 9749 9750 response, ok := out.RawResponse.(*smithyhttp.Response) 9751 if !ok { 9752 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9753 } 9754 9755 if response.StatusCode < 200 || response.StatusCode >= 300 { 9756 return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response, &metadata) 9757 } 9758 output := &UpdateTrafficPolicyInstanceOutput{} 9759 out.Result = output 9760 9761 var buff [1024]byte 9762 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9763 body := io.TeeReader(response.Body, ringBuffer) 9764 rootDecoder := xml.NewDecoder(body) 9765 t, err := smithyxml.FetchRootElement(rootDecoder) 9766 if err == io.EOF { 9767 return out, metadata, nil 9768 } 9769 if err != nil { 9770 var snapshot bytes.Buffer 9771 io.Copy(&snapshot, ringBuffer) 9772 return out, metadata, &smithy.DeserializationError{ 9773 Err: fmt.Errorf("failed to decode response body, %w", err), 9774 Snapshot: snapshot.Bytes(), 9775 } 9776 } 9777 9778 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9779 err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(&output, decoder) 9780 if err != nil { 9781 var snapshot bytes.Buffer 9782 io.Copy(&snapshot, ringBuffer) 9783 return out, metadata, &smithy.DeserializationError{ 9784 Err: fmt.Errorf("failed to decode response body, %w", err), 9785 Snapshot: snapshot.Bytes(), 9786 } 9787 } 9788 9789 return out, metadata, err 9790} 9791 9792func awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9793 var errorBuffer bytes.Buffer 9794 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9795 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9796 } 9797 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9798 9799 errorCode := "UnknownError" 9800 errorMessage := errorCode 9801 9802 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9803 if err != nil { 9804 return err 9805 } 9806 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9807 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9808 } 9809 if len(errorComponents.Code) != 0 { 9810 errorCode = errorComponents.Code 9811 } 9812 if len(errorComponents.Message) != 0 { 9813 errorMessage = errorComponents.Message 9814 } 9815 errorBody.Seek(0, io.SeekStart) 9816 switch { 9817 case strings.EqualFold("ConflictingTypes", errorCode): 9818 return awsRestxml_deserializeErrorConflictingTypes(response, errorBody) 9819 9820 case strings.EqualFold("InvalidInput", errorCode): 9821 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9822 9823 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 9824 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 9825 9826 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 9827 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 9828 9829 case strings.EqualFold("PriorRequestNotComplete", errorCode): 9830 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 9831 9832 default: 9833 genericError := &smithy.GenericAPIError{ 9834 Code: errorCode, 9835 Message: errorMessage, 9836 } 9837 return genericError 9838 9839 } 9840} 9841 9842func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(v **UpdateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error { 9843 if v == nil { 9844 return fmt.Errorf("unexpected nil of type %T", v) 9845 } 9846 var sv *UpdateTrafficPolicyInstanceOutput 9847 if *v == nil { 9848 sv = &UpdateTrafficPolicyInstanceOutput{} 9849 } else { 9850 sv = *v 9851 } 9852 9853 for { 9854 t, done, err := decoder.Token() 9855 if err != nil { 9856 return err 9857 } 9858 if done { 9859 break 9860 } 9861 originalDecoder := decoder 9862 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9863 switch { 9864 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 9865 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9866 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil { 9867 return err 9868 } 9869 9870 default: 9871 // Do nothing and ignore the unexpected tag element 9872 err = decoder.Decoder.Skip() 9873 if err != nil { 9874 return err 9875 } 9876 9877 } 9878 decoder = originalDecoder 9879 } 9880 *v = sv 9881 return nil 9882} 9883 9884func awsRestxml_deserializeErrorConcurrentModification(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9885 output := &types.ConcurrentModification{} 9886 var buff [1024]byte 9887 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9888 body := io.TeeReader(errorBody, ringBuffer) 9889 rootDecoder := xml.NewDecoder(body) 9890 t, err := smithyxml.FetchRootElement(rootDecoder) 9891 if err == io.EOF { 9892 return output 9893 } 9894 if err != nil { 9895 var snapshot bytes.Buffer 9896 io.Copy(&snapshot, ringBuffer) 9897 return &smithy.DeserializationError{ 9898 Err: fmt.Errorf("failed to decode response body, %w", err), 9899 Snapshot: snapshot.Bytes(), 9900 } 9901 } 9902 9903 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9904 t, err = decoder.GetElement("Error") 9905 if err != nil { 9906 var snapshot bytes.Buffer 9907 io.Copy(&snapshot, ringBuffer) 9908 return &smithy.DeserializationError{ 9909 Err: fmt.Errorf("failed to decode response body, %w", err), 9910 Snapshot: snapshot.Bytes(), 9911 } 9912 } 9913 9914 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9915 err = awsRestxml_deserializeDocumentConcurrentModification(&output, decoder) 9916 if err != nil { 9917 var snapshot bytes.Buffer 9918 io.Copy(&snapshot, ringBuffer) 9919 return &smithy.DeserializationError{ 9920 Err: fmt.Errorf("failed to decode response body, %w", err), 9921 Snapshot: snapshot.Bytes(), 9922 } 9923 } 9924 9925 return output 9926} 9927 9928func awsRestxml_deserializeErrorConflictingDomainExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9929 output := &types.ConflictingDomainExists{} 9930 var buff [1024]byte 9931 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9932 body := io.TeeReader(errorBody, ringBuffer) 9933 rootDecoder := xml.NewDecoder(body) 9934 t, err := smithyxml.FetchRootElement(rootDecoder) 9935 if err == io.EOF { 9936 return output 9937 } 9938 if err != nil { 9939 var snapshot bytes.Buffer 9940 io.Copy(&snapshot, ringBuffer) 9941 return &smithy.DeserializationError{ 9942 Err: fmt.Errorf("failed to decode response body, %w", err), 9943 Snapshot: snapshot.Bytes(), 9944 } 9945 } 9946 9947 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9948 t, err = decoder.GetElement("Error") 9949 if err != nil { 9950 var snapshot bytes.Buffer 9951 io.Copy(&snapshot, ringBuffer) 9952 return &smithy.DeserializationError{ 9953 Err: fmt.Errorf("failed to decode response body, %w", err), 9954 Snapshot: snapshot.Bytes(), 9955 } 9956 } 9957 9958 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9959 err = awsRestxml_deserializeDocumentConflictingDomainExists(&output, decoder) 9960 if err != nil { 9961 var snapshot bytes.Buffer 9962 io.Copy(&snapshot, ringBuffer) 9963 return &smithy.DeserializationError{ 9964 Err: fmt.Errorf("failed to decode response body, %w", err), 9965 Snapshot: snapshot.Bytes(), 9966 } 9967 } 9968 9969 return output 9970} 9971 9972func awsRestxml_deserializeErrorConflictingTypes(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9973 output := &types.ConflictingTypes{} 9974 var buff [1024]byte 9975 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9976 body := io.TeeReader(errorBody, ringBuffer) 9977 rootDecoder := xml.NewDecoder(body) 9978 t, err := smithyxml.FetchRootElement(rootDecoder) 9979 if err == io.EOF { 9980 return output 9981 } 9982 if err != nil { 9983 var snapshot bytes.Buffer 9984 io.Copy(&snapshot, ringBuffer) 9985 return &smithy.DeserializationError{ 9986 Err: fmt.Errorf("failed to decode response body, %w", err), 9987 Snapshot: snapshot.Bytes(), 9988 } 9989 } 9990 9991 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9992 t, err = decoder.GetElement("Error") 9993 if err != nil { 9994 var snapshot bytes.Buffer 9995 io.Copy(&snapshot, ringBuffer) 9996 return &smithy.DeserializationError{ 9997 Err: fmt.Errorf("failed to decode response body, %w", err), 9998 Snapshot: snapshot.Bytes(), 9999 } 10000 } 10001 10002 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10003 err = awsRestxml_deserializeDocumentConflictingTypes(&output, decoder) 10004 if err != nil { 10005 var snapshot bytes.Buffer 10006 io.Copy(&snapshot, ringBuffer) 10007 return &smithy.DeserializationError{ 10008 Err: fmt.Errorf("failed to decode response body, %w", err), 10009 Snapshot: snapshot.Bytes(), 10010 } 10011 } 10012 10013 return output 10014} 10015 10016func awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10017 output := &types.DelegationSetAlreadyCreated{} 10018 var buff [1024]byte 10019 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10020 body := io.TeeReader(errorBody, ringBuffer) 10021 rootDecoder := xml.NewDecoder(body) 10022 t, err := smithyxml.FetchRootElement(rootDecoder) 10023 if err == io.EOF { 10024 return output 10025 } 10026 if err != nil { 10027 var snapshot bytes.Buffer 10028 io.Copy(&snapshot, ringBuffer) 10029 return &smithy.DeserializationError{ 10030 Err: fmt.Errorf("failed to decode response body, %w", err), 10031 Snapshot: snapshot.Bytes(), 10032 } 10033 } 10034 10035 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10036 t, err = decoder.GetElement("Error") 10037 if err != nil { 10038 var snapshot bytes.Buffer 10039 io.Copy(&snapshot, ringBuffer) 10040 return &smithy.DeserializationError{ 10041 Err: fmt.Errorf("failed to decode response body, %w", err), 10042 Snapshot: snapshot.Bytes(), 10043 } 10044 } 10045 10046 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10047 err = awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(&output, decoder) 10048 if err != nil { 10049 var snapshot bytes.Buffer 10050 io.Copy(&snapshot, ringBuffer) 10051 return &smithy.DeserializationError{ 10052 Err: fmt.Errorf("failed to decode response body, %w", err), 10053 Snapshot: snapshot.Bytes(), 10054 } 10055 } 10056 10057 return output 10058} 10059 10060func awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10061 output := &types.DelegationSetAlreadyReusable{} 10062 var buff [1024]byte 10063 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10064 body := io.TeeReader(errorBody, ringBuffer) 10065 rootDecoder := xml.NewDecoder(body) 10066 t, err := smithyxml.FetchRootElement(rootDecoder) 10067 if err == io.EOF { 10068 return output 10069 } 10070 if err != nil { 10071 var snapshot bytes.Buffer 10072 io.Copy(&snapshot, ringBuffer) 10073 return &smithy.DeserializationError{ 10074 Err: fmt.Errorf("failed to decode response body, %w", err), 10075 Snapshot: snapshot.Bytes(), 10076 } 10077 } 10078 10079 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10080 t, err = decoder.GetElement("Error") 10081 if err != nil { 10082 var snapshot bytes.Buffer 10083 io.Copy(&snapshot, ringBuffer) 10084 return &smithy.DeserializationError{ 10085 Err: fmt.Errorf("failed to decode response body, %w", err), 10086 Snapshot: snapshot.Bytes(), 10087 } 10088 } 10089 10090 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10091 err = awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(&output, decoder) 10092 if err != nil { 10093 var snapshot bytes.Buffer 10094 io.Copy(&snapshot, ringBuffer) 10095 return &smithy.DeserializationError{ 10096 Err: fmt.Errorf("failed to decode response body, %w", err), 10097 Snapshot: snapshot.Bytes(), 10098 } 10099 } 10100 10101 return output 10102} 10103 10104func awsRestxml_deserializeErrorDelegationSetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10105 output := &types.DelegationSetInUse{} 10106 var buff [1024]byte 10107 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10108 body := io.TeeReader(errorBody, ringBuffer) 10109 rootDecoder := xml.NewDecoder(body) 10110 t, err := smithyxml.FetchRootElement(rootDecoder) 10111 if err == io.EOF { 10112 return output 10113 } 10114 if err != nil { 10115 var snapshot bytes.Buffer 10116 io.Copy(&snapshot, ringBuffer) 10117 return &smithy.DeserializationError{ 10118 Err: fmt.Errorf("failed to decode response body, %w", err), 10119 Snapshot: snapshot.Bytes(), 10120 } 10121 } 10122 10123 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10124 t, err = decoder.GetElement("Error") 10125 if err != nil { 10126 var snapshot bytes.Buffer 10127 io.Copy(&snapshot, ringBuffer) 10128 return &smithy.DeserializationError{ 10129 Err: fmt.Errorf("failed to decode response body, %w", err), 10130 Snapshot: snapshot.Bytes(), 10131 } 10132 } 10133 10134 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10135 err = awsRestxml_deserializeDocumentDelegationSetInUse(&output, decoder) 10136 if err != nil { 10137 var snapshot bytes.Buffer 10138 io.Copy(&snapshot, ringBuffer) 10139 return &smithy.DeserializationError{ 10140 Err: fmt.Errorf("failed to decode response body, %w", err), 10141 Snapshot: snapshot.Bytes(), 10142 } 10143 } 10144 10145 return output 10146} 10147 10148func awsRestxml_deserializeErrorDelegationSetNotAvailable(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10149 output := &types.DelegationSetNotAvailable{} 10150 var buff [1024]byte 10151 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10152 body := io.TeeReader(errorBody, ringBuffer) 10153 rootDecoder := xml.NewDecoder(body) 10154 t, err := smithyxml.FetchRootElement(rootDecoder) 10155 if err == io.EOF { 10156 return output 10157 } 10158 if err != nil { 10159 var snapshot bytes.Buffer 10160 io.Copy(&snapshot, ringBuffer) 10161 return &smithy.DeserializationError{ 10162 Err: fmt.Errorf("failed to decode response body, %w", err), 10163 Snapshot: snapshot.Bytes(), 10164 } 10165 } 10166 10167 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10168 t, err = decoder.GetElement("Error") 10169 if err != nil { 10170 var snapshot bytes.Buffer 10171 io.Copy(&snapshot, ringBuffer) 10172 return &smithy.DeserializationError{ 10173 Err: fmt.Errorf("failed to decode response body, %w", err), 10174 Snapshot: snapshot.Bytes(), 10175 } 10176 } 10177 10178 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10179 err = awsRestxml_deserializeDocumentDelegationSetNotAvailable(&output, decoder) 10180 if err != nil { 10181 var snapshot bytes.Buffer 10182 io.Copy(&snapshot, ringBuffer) 10183 return &smithy.DeserializationError{ 10184 Err: fmt.Errorf("failed to decode response body, %w", err), 10185 Snapshot: snapshot.Bytes(), 10186 } 10187 } 10188 10189 return output 10190} 10191 10192func awsRestxml_deserializeErrorDelegationSetNotReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10193 output := &types.DelegationSetNotReusable{} 10194 var buff [1024]byte 10195 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10196 body := io.TeeReader(errorBody, ringBuffer) 10197 rootDecoder := xml.NewDecoder(body) 10198 t, err := smithyxml.FetchRootElement(rootDecoder) 10199 if err == io.EOF { 10200 return output 10201 } 10202 if err != nil { 10203 var snapshot bytes.Buffer 10204 io.Copy(&snapshot, ringBuffer) 10205 return &smithy.DeserializationError{ 10206 Err: fmt.Errorf("failed to decode response body, %w", err), 10207 Snapshot: snapshot.Bytes(), 10208 } 10209 } 10210 10211 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10212 t, err = decoder.GetElement("Error") 10213 if err != nil { 10214 var snapshot bytes.Buffer 10215 io.Copy(&snapshot, ringBuffer) 10216 return &smithy.DeserializationError{ 10217 Err: fmt.Errorf("failed to decode response body, %w", err), 10218 Snapshot: snapshot.Bytes(), 10219 } 10220 } 10221 10222 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10223 err = awsRestxml_deserializeDocumentDelegationSetNotReusable(&output, decoder) 10224 if err != nil { 10225 var snapshot bytes.Buffer 10226 io.Copy(&snapshot, ringBuffer) 10227 return &smithy.DeserializationError{ 10228 Err: fmt.Errorf("failed to decode response body, %w", err), 10229 Snapshot: snapshot.Bytes(), 10230 } 10231 } 10232 10233 return output 10234} 10235 10236func awsRestxml_deserializeErrorDNSSECNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10237 output := &types.DNSSECNotFound{} 10238 var buff [1024]byte 10239 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10240 body := io.TeeReader(errorBody, ringBuffer) 10241 rootDecoder := xml.NewDecoder(body) 10242 t, err := smithyxml.FetchRootElement(rootDecoder) 10243 if err == io.EOF { 10244 return output 10245 } 10246 if err != nil { 10247 var snapshot bytes.Buffer 10248 io.Copy(&snapshot, ringBuffer) 10249 return &smithy.DeserializationError{ 10250 Err: fmt.Errorf("failed to decode response body, %w", err), 10251 Snapshot: snapshot.Bytes(), 10252 } 10253 } 10254 10255 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10256 t, err = decoder.GetElement("Error") 10257 if err != nil { 10258 var snapshot bytes.Buffer 10259 io.Copy(&snapshot, ringBuffer) 10260 return &smithy.DeserializationError{ 10261 Err: fmt.Errorf("failed to decode response body, %w", err), 10262 Snapshot: snapshot.Bytes(), 10263 } 10264 } 10265 10266 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10267 err = awsRestxml_deserializeDocumentDNSSECNotFound(&output, decoder) 10268 if err != nil { 10269 var snapshot bytes.Buffer 10270 io.Copy(&snapshot, ringBuffer) 10271 return &smithy.DeserializationError{ 10272 Err: fmt.Errorf("failed to decode response body, %w", err), 10273 Snapshot: snapshot.Bytes(), 10274 } 10275 } 10276 10277 return output 10278} 10279 10280func awsRestxml_deserializeErrorHealthCheckAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10281 output := &types.HealthCheckAlreadyExists{} 10282 var buff [1024]byte 10283 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10284 body := io.TeeReader(errorBody, ringBuffer) 10285 rootDecoder := xml.NewDecoder(body) 10286 t, err := smithyxml.FetchRootElement(rootDecoder) 10287 if err == io.EOF { 10288 return output 10289 } 10290 if err != nil { 10291 var snapshot bytes.Buffer 10292 io.Copy(&snapshot, ringBuffer) 10293 return &smithy.DeserializationError{ 10294 Err: fmt.Errorf("failed to decode response body, %w", err), 10295 Snapshot: snapshot.Bytes(), 10296 } 10297 } 10298 10299 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10300 t, err = decoder.GetElement("Error") 10301 if err != nil { 10302 var snapshot bytes.Buffer 10303 io.Copy(&snapshot, ringBuffer) 10304 return &smithy.DeserializationError{ 10305 Err: fmt.Errorf("failed to decode response body, %w", err), 10306 Snapshot: snapshot.Bytes(), 10307 } 10308 } 10309 10310 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10311 err = awsRestxml_deserializeDocumentHealthCheckAlreadyExists(&output, decoder) 10312 if err != nil { 10313 var snapshot bytes.Buffer 10314 io.Copy(&snapshot, ringBuffer) 10315 return &smithy.DeserializationError{ 10316 Err: fmt.Errorf("failed to decode response body, %w", err), 10317 Snapshot: snapshot.Bytes(), 10318 } 10319 } 10320 10321 return output 10322} 10323 10324func awsRestxml_deserializeErrorHealthCheckInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10325 output := &types.HealthCheckInUse{} 10326 var buff [1024]byte 10327 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10328 body := io.TeeReader(errorBody, ringBuffer) 10329 rootDecoder := xml.NewDecoder(body) 10330 t, err := smithyxml.FetchRootElement(rootDecoder) 10331 if err == io.EOF { 10332 return output 10333 } 10334 if err != nil { 10335 var snapshot bytes.Buffer 10336 io.Copy(&snapshot, ringBuffer) 10337 return &smithy.DeserializationError{ 10338 Err: fmt.Errorf("failed to decode response body, %w", err), 10339 Snapshot: snapshot.Bytes(), 10340 } 10341 } 10342 10343 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10344 t, err = decoder.GetElement("Error") 10345 if err != nil { 10346 var snapshot bytes.Buffer 10347 io.Copy(&snapshot, ringBuffer) 10348 return &smithy.DeserializationError{ 10349 Err: fmt.Errorf("failed to decode response body, %w", err), 10350 Snapshot: snapshot.Bytes(), 10351 } 10352 } 10353 10354 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10355 err = awsRestxml_deserializeDocumentHealthCheckInUse(&output, decoder) 10356 if err != nil { 10357 var snapshot bytes.Buffer 10358 io.Copy(&snapshot, ringBuffer) 10359 return &smithy.DeserializationError{ 10360 Err: fmt.Errorf("failed to decode response body, %w", err), 10361 Snapshot: snapshot.Bytes(), 10362 } 10363 } 10364 10365 return output 10366} 10367 10368func awsRestxml_deserializeErrorHealthCheckVersionMismatch(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10369 output := &types.HealthCheckVersionMismatch{} 10370 var buff [1024]byte 10371 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10372 body := io.TeeReader(errorBody, ringBuffer) 10373 rootDecoder := xml.NewDecoder(body) 10374 t, err := smithyxml.FetchRootElement(rootDecoder) 10375 if err == io.EOF { 10376 return output 10377 } 10378 if err != nil { 10379 var snapshot bytes.Buffer 10380 io.Copy(&snapshot, ringBuffer) 10381 return &smithy.DeserializationError{ 10382 Err: fmt.Errorf("failed to decode response body, %w", err), 10383 Snapshot: snapshot.Bytes(), 10384 } 10385 } 10386 10387 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10388 t, err = decoder.GetElement("Error") 10389 if err != nil { 10390 var snapshot bytes.Buffer 10391 io.Copy(&snapshot, ringBuffer) 10392 return &smithy.DeserializationError{ 10393 Err: fmt.Errorf("failed to decode response body, %w", err), 10394 Snapshot: snapshot.Bytes(), 10395 } 10396 } 10397 10398 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10399 err = awsRestxml_deserializeDocumentHealthCheckVersionMismatch(&output, decoder) 10400 if err != nil { 10401 var snapshot bytes.Buffer 10402 io.Copy(&snapshot, ringBuffer) 10403 return &smithy.DeserializationError{ 10404 Err: fmt.Errorf("failed to decode response body, %w", err), 10405 Snapshot: snapshot.Bytes(), 10406 } 10407 } 10408 10409 return output 10410} 10411 10412func awsRestxml_deserializeErrorHostedZoneAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10413 output := &types.HostedZoneAlreadyExists{} 10414 var buff [1024]byte 10415 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10416 body := io.TeeReader(errorBody, ringBuffer) 10417 rootDecoder := xml.NewDecoder(body) 10418 t, err := smithyxml.FetchRootElement(rootDecoder) 10419 if err == io.EOF { 10420 return output 10421 } 10422 if err != nil { 10423 var snapshot bytes.Buffer 10424 io.Copy(&snapshot, ringBuffer) 10425 return &smithy.DeserializationError{ 10426 Err: fmt.Errorf("failed to decode response body, %w", err), 10427 Snapshot: snapshot.Bytes(), 10428 } 10429 } 10430 10431 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10432 t, err = decoder.GetElement("Error") 10433 if err != nil { 10434 var snapshot bytes.Buffer 10435 io.Copy(&snapshot, ringBuffer) 10436 return &smithy.DeserializationError{ 10437 Err: fmt.Errorf("failed to decode response body, %w", err), 10438 Snapshot: snapshot.Bytes(), 10439 } 10440 } 10441 10442 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10443 err = awsRestxml_deserializeDocumentHostedZoneAlreadyExists(&output, decoder) 10444 if err != nil { 10445 var snapshot bytes.Buffer 10446 io.Copy(&snapshot, ringBuffer) 10447 return &smithy.DeserializationError{ 10448 Err: fmt.Errorf("failed to decode response body, %w", err), 10449 Snapshot: snapshot.Bytes(), 10450 } 10451 } 10452 10453 return output 10454} 10455 10456func awsRestxml_deserializeErrorHostedZoneNotEmpty(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10457 output := &types.HostedZoneNotEmpty{} 10458 var buff [1024]byte 10459 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10460 body := io.TeeReader(errorBody, ringBuffer) 10461 rootDecoder := xml.NewDecoder(body) 10462 t, err := smithyxml.FetchRootElement(rootDecoder) 10463 if err == io.EOF { 10464 return output 10465 } 10466 if err != nil { 10467 var snapshot bytes.Buffer 10468 io.Copy(&snapshot, ringBuffer) 10469 return &smithy.DeserializationError{ 10470 Err: fmt.Errorf("failed to decode response body, %w", err), 10471 Snapshot: snapshot.Bytes(), 10472 } 10473 } 10474 10475 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10476 t, err = decoder.GetElement("Error") 10477 if err != nil { 10478 var snapshot bytes.Buffer 10479 io.Copy(&snapshot, ringBuffer) 10480 return &smithy.DeserializationError{ 10481 Err: fmt.Errorf("failed to decode response body, %w", err), 10482 Snapshot: snapshot.Bytes(), 10483 } 10484 } 10485 10486 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10487 err = awsRestxml_deserializeDocumentHostedZoneNotEmpty(&output, decoder) 10488 if err != nil { 10489 var snapshot bytes.Buffer 10490 io.Copy(&snapshot, ringBuffer) 10491 return &smithy.DeserializationError{ 10492 Err: fmt.Errorf("failed to decode response body, %w", err), 10493 Snapshot: snapshot.Bytes(), 10494 } 10495 } 10496 10497 return output 10498} 10499 10500func awsRestxml_deserializeErrorHostedZoneNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10501 output := &types.HostedZoneNotFound{} 10502 var buff [1024]byte 10503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10504 body := io.TeeReader(errorBody, ringBuffer) 10505 rootDecoder := xml.NewDecoder(body) 10506 t, err := smithyxml.FetchRootElement(rootDecoder) 10507 if err == io.EOF { 10508 return output 10509 } 10510 if err != nil { 10511 var snapshot bytes.Buffer 10512 io.Copy(&snapshot, ringBuffer) 10513 return &smithy.DeserializationError{ 10514 Err: fmt.Errorf("failed to decode response body, %w", err), 10515 Snapshot: snapshot.Bytes(), 10516 } 10517 } 10518 10519 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10520 t, err = decoder.GetElement("Error") 10521 if err != nil { 10522 var snapshot bytes.Buffer 10523 io.Copy(&snapshot, ringBuffer) 10524 return &smithy.DeserializationError{ 10525 Err: fmt.Errorf("failed to decode response body, %w", err), 10526 Snapshot: snapshot.Bytes(), 10527 } 10528 } 10529 10530 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10531 err = awsRestxml_deserializeDocumentHostedZoneNotFound(&output, decoder) 10532 if err != nil { 10533 var snapshot bytes.Buffer 10534 io.Copy(&snapshot, ringBuffer) 10535 return &smithy.DeserializationError{ 10536 Err: fmt.Errorf("failed to decode response body, %w", err), 10537 Snapshot: snapshot.Bytes(), 10538 } 10539 } 10540 10541 return output 10542} 10543 10544func awsRestxml_deserializeErrorHostedZoneNotPrivate(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10545 output := &types.HostedZoneNotPrivate{} 10546 var buff [1024]byte 10547 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10548 body := io.TeeReader(errorBody, ringBuffer) 10549 rootDecoder := xml.NewDecoder(body) 10550 t, err := smithyxml.FetchRootElement(rootDecoder) 10551 if err == io.EOF { 10552 return output 10553 } 10554 if err != nil { 10555 var snapshot bytes.Buffer 10556 io.Copy(&snapshot, ringBuffer) 10557 return &smithy.DeserializationError{ 10558 Err: fmt.Errorf("failed to decode response body, %w", err), 10559 Snapshot: snapshot.Bytes(), 10560 } 10561 } 10562 10563 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10564 t, err = decoder.GetElement("Error") 10565 if err != nil { 10566 var snapshot bytes.Buffer 10567 io.Copy(&snapshot, ringBuffer) 10568 return &smithy.DeserializationError{ 10569 Err: fmt.Errorf("failed to decode response body, %w", err), 10570 Snapshot: snapshot.Bytes(), 10571 } 10572 } 10573 10574 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10575 err = awsRestxml_deserializeDocumentHostedZoneNotPrivate(&output, decoder) 10576 if err != nil { 10577 var snapshot bytes.Buffer 10578 io.Copy(&snapshot, ringBuffer) 10579 return &smithy.DeserializationError{ 10580 Err: fmt.Errorf("failed to decode response body, %w", err), 10581 Snapshot: snapshot.Bytes(), 10582 } 10583 } 10584 10585 return output 10586} 10587 10588func awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10589 output := &types.HostedZonePartiallyDelegated{} 10590 var buff [1024]byte 10591 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10592 body := io.TeeReader(errorBody, ringBuffer) 10593 rootDecoder := xml.NewDecoder(body) 10594 t, err := smithyxml.FetchRootElement(rootDecoder) 10595 if err == io.EOF { 10596 return output 10597 } 10598 if err != nil { 10599 var snapshot bytes.Buffer 10600 io.Copy(&snapshot, ringBuffer) 10601 return &smithy.DeserializationError{ 10602 Err: fmt.Errorf("failed to decode response body, %w", err), 10603 Snapshot: snapshot.Bytes(), 10604 } 10605 } 10606 10607 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10608 t, err = decoder.GetElement("Error") 10609 if err != nil { 10610 var snapshot bytes.Buffer 10611 io.Copy(&snapshot, ringBuffer) 10612 return &smithy.DeserializationError{ 10613 Err: fmt.Errorf("failed to decode response body, %w", err), 10614 Snapshot: snapshot.Bytes(), 10615 } 10616 } 10617 10618 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10619 err = awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(&output, decoder) 10620 if err != nil { 10621 var snapshot bytes.Buffer 10622 io.Copy(&snapshot, ringBuffer) 10623 return &smithy.DeserializationError{ 10624 Err: fmt.Errorf("failed to decode response body, %w", err), 10625 Snapshot: snapshot.Bytes(), 10626 } 10627 } 10628 10629 return output 10630} 10631 10632func awsRestxml_deserializeErrorIncompatibleVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10633 output := &types.IncompatibleVersion{} 10634 var buff [1024]byte 10635 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10636 body := io.TeeReader(errorBody, ringBuffer) 10637 rootDecoder := xml.NewDecoder(body) 10638 t, err := smithyxml.FetchRootElement(rootDecoder) 10639 if err == io.EOF { 10640 return output 10641 } 10642 if err != nil { 10643 var snapshot bytes.Buffer 10644 io.Copy(&snapshot, ringBuffer) 10645 return &smithy.DeserializationError{ 10646 Err: fmt.Errorf("failed to decode response body, %w", err), 10647 Snapshot: snapshot.Bytes(), 10648 } 10649 } 10650 10651 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10652 t, err = decoder.GetElement("Error") 10653 if err != nil { 10654 var snapshot bytes.Buffer 10655 io.Copy(&snapshot, ringBuffer) 10656 return &smithy.DeserializationError{ 10657 Err: fmt.Errorf("failed to decode response body, %w", err), 10658 Snapshot: snapshot.Bytes(), 10659 } 10660 } 10661 10662 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10663 err = awsRestxml_deserializeDocumentIncompatibleVersion(&output, decoder) 10664 if err != nil { 10665 var snapshot bytes.Buffer 10666 io.Copy(&snapshot, ringBuffer) 10667 return &smithy.DeserializationError{ 10668 Err: fmt.Errorf("failed to decode response body, %w", err), 10669 Snapshot: snapshot.Bytes(), 10670 } 10671 } 10672 10673 return output 10674} 10675 10676func awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10677 output := &types.InsufficientCloudWatchLogsResourcePolicy{} 10678 var buff [1024]byte 10679 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10680 body := io.TeeReader(errorBody, ringBuffer) 10681 rootDecoder := xml.NewDecoder(body) 10682 t, err := smithyxml.FetchRootElement(rootDecoder) 10683 if err == io.EOF { 10684 return output 10685 } 10686 if err != nil { 10687 var snapshot bytes.Buffer 10688 io.Copy(&snapshot, ringBuffer) 10689 return &smithy.DeserializationError{ 10690 Err: fmt.Errorf("failed to decode response body, %w", err), 10691 Snapshot: snapshot.Bytes(), 10692 } 10693 } 10694 10695 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10696 t, err = decoder.GetElement("Error") 10697 if err != nil { 10698 var snapshot bytes.Buffer 10699 io.Copy(&snapshot, ringBuffer) 10700 return &smithy.DeserializationError{ 10701 Err: fmt.Errorf("failed to decode response body, %w", err), 10702 Snapshot: snapshot.Bytes(), 10703 } 10704 } 10705 10706 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10707 err = awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(&output, decoder) 10708 if err != nil { 10709 var snapshot bytes.Buffer 10710 io.Copy(&snapshot, ringBuffer) 10711 return &smithy.DeserializationError{ 10712 Err: fmt.Errorf("failed to decode response body, %w", err), 10713 Snapshot: snapshot.Bytes(), 10714 } 10715 } 10716 10717 return output 10718} 10719 10720func awsRestxml_deserializeErrorInvalidArgument(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10721 output := &types.InvalidArgument{} 10722 var buff [1024]byte 10723 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10724 body := io.TeeReader(errorBody, ringBuffer) 10725 rootDecoder := xml.NewDecoder(body) 10726 t, err := smithyxml.FetchRootElement(rootDecoder) 10727 if err == io.EOF { 10728 return output 10729 } 10730 if err != nil { 10731 var snapshot bytes.Buffer 10732 io.Copy(&snapshot, ringBuffer) 10733 return &smithy.DeserializationError{ 10734 Err: fmt.Errorf("failed to decode response body, %w", err), 10735 Snapshot: snapshot.Bytes(), 10736 } 10737 } 10738 10739 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10740 t, err = decoder.GetElement("Error") 10741 if err != nil { 10742 var snapshot bytes.Buffer 10743 io.Copy(&snapshot, ringBuffer) 10744 return &smithy.DeserializationError{ 10745 Err: fmt.Errorf("failed to decode response body, %w", err), 10746 Snapshot: snapshot.Bytes(), 10747 } 10748 } 10749 10750 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10751 err = awsRestxml_deserializeDocumentInvalidArgument(&output, decoder) 10752 if err != nil { 10753 var snapshot bytes.Buffer 10754 io.Copy(&snapshot, ringBuffer) 10755 return &smithy.DeserializationError{ 10756 Err: fmt.Errorf("failed to decode response body, %w", err), 10757 Snapshot: snapshot.Bytes(), 10758 } 10759 } 10760 10761 return output 10762} 10763 10764func awsRestxml_deserializeErrorInvalidChangeBatch(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10765 output := &types.InvalidChangeBatch{} 10766 var buff [1024]byte 10767 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10768 body := io.TeeReader(errorBody, ringBuffer) 10769 rootDecoder := xml.NewDecoder(body) 10770 t, err := smithyxml.FetchRootElement(rootDecoder) 10771 if err == io.EOF { 10772 return output 10773 } 10774 if err != nil { 10775 var snapshot bytes.Buffer 10776 io.Copy(&snapshot, ringBuffer) 10777 return &smithy.DeserializationError{ 10778 Err: fmt.Errorf("failed to decode response body, %w", err), 10779 Snapshot: snapshot.Bytes(), 10780 } 10781 } 10782 10783 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10784 t, err = decoder.GetElement("Error") 10785 if err != nil { 10786 var snapshot bytes.Buffer 10787 io.Copy(&snapshot, ringBuffer) 10788 return &smithy.DeserializationError{ 10789 Err: fmt.Errorf("failed to decode response body, %w", err), 10790 Snapshot: snapshot.Bytes(), 10791 } 10792 } 10793 10794 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10795 err = awsRestxml_deserializeDocumentInvalidChangeBatch(&output, decoder) 10796 if err != nil { 10797 var snapshot bytes.Buffer 10798 io.Copy(&snapshot, ringBuffer) 10799 return &smithy.DeserializationError{ 10800 Err: fmt.Errorf("failed to decode response body, %w", err), 10801 Snapshot: snapshot.Bytes(), 10802 } 10803 } 10804 10805 return output 10806} 10807 10808func awsRestxml_deserializeErrorInvalidDomainName(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10809 output := &types.InvalidDomainName{} 10810 var buff [1024]byte 10811 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10812 body := io.TeeReader(errorBody, ringBuffer) 10813 rootDecoder := xml.NewDecoder(body) 10814 t, err := smithyxml.FetchRootElement(rootDecoder) 10815 if err == io.EOF { 10816 return output 10817 } 10818 if err != nil { 10819 var snapshot bytes.Buffer 10820 io.Copy(&snapshot, ringBuffer) 10821 return &smithy.DeserializationError{ 10822 Err: fmt.Errorf("failed to decode response body, %w", err), 10823 Snapshot: snapshot.Bytes(), 10824 } 10825 } 10826 10827 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10828 t, err = decoder.GetElement("Error") 10829 if err != nil { 10830 var snapshot bytes.Buffer 10831 io.Copy(&snapshot, ringBuffer) 10832 return &smithy.DeserializationError{ 10833 Err: fmt.Errorf("failed to decode response body, %w", err), 10834 Snapshot: snapshot.Bytes(), 10835 } 10836 } 10837 10838 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10839 err = awsRestxml_deserializeDocumentInvalidDomainName(&output, decoder) 10840 if err != nil { 10841 var snapshot bytes.Buffer 10842 io.Copy(&snapshot, ringBuffer) 10843 return &smithy.DeserializationError{ 10844 Err: fmt.Errorf("failed to decode response body, %w", err), 10845 Snapshot: snapshot.Bytes(), 10846 } 10847 } 10848 10849 return output 10850} 10851 10852func awsRestxml_deserializeErrorInvalidInput(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10853 output := &types.InvalidInput{} 10854 var buff [1024]byte 10855 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10856 body := io.TeeReader(errorBody, ringBuffer) 10857 rootDecoder := xml.NewDecoder(body) 10858 t, err := smithyxml.FetchRootElement(rootDecoder) 10859 if err == io.EOF { 10860 return output 10861 } 10862 if err != nil { 10863 var snapshot bytes.Buffer 10864 io.Copy(&snapshot, ringBuffer) 10865 return &smithy.DeserializationError{ 10866 Err: fmt.Errorf("failed to decode response body, %w", err), 10867 Snapshot: snapshot.Bytes(), 10868 } 10869 } 10870 10871 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10872 t, err = decoder.GetElement("Error") 10873 if err != nil { 10874 var snapshot bytes.Buffer 10875 io.Copy(&snapshot, ringBuffer) 10876 return &smithy.DeserializationError{ 10877 Err: fmt.Errorf("failed to decode response body, %w", err), 10878 Snapshot: snapshot.Bytes(), 10879 } 10880 } 10881 10882 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10883 err = awsRestxml_deserializeDocumentInvalidInput(&output, decoder) 10884 if err != nil { 10885 var snapshot bytes.Buffer 10886 io.Copy(&snapshot, ringBuffer) 10887 return &smithy.DeserializationError{ 10888 Err: fmt.Errorf("failed to decode response body, %w", err), 10889 Snapshot: snapshot.Bytes(), 10890 } 10891 } 10892 10893 return output 10894} 10895 10896func awsRestxml_deserializeErrorInvalidKeySigningKeyName(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10897 output := &types.InvalidKeySigningKeyName{} 10898 var buff [1024]byte 10899 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10900 body := io.TeeReader(errorBody, ringBuffer) 10901 rootDecoder := xml.NewDecoder(body) 10902 t, err := smithyxml.FetchRootElement(rootDecoder) 10903 if err == io.EOF { 10904 return output 10905 } 10906 if err != nil { 10907 var snapshot bytes.Buffer 10908 io.Copy(&snapshot, ringBuffer) 10909 return &smithy.DeserializationError{ 10910 Err: fmt.Errorf("failed to decode response body, %w", err), 10911 Snapshot: snapshot.Bytes(), 10912 } 10913 } 10914 10915 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10916 t, err = decoder.GetElement("Error") 10917 if err != nil { 10918 var snapshot bytes.Buffer 10919 io.Copy(&snapshot, ringBuffer) 10920 return &smithy.DeserializationError{ 10921 Err: fmt.Errorf("failed to decode response body, %w", err), 10922 Snapshot: snapshot.Bytes(), 10923 } 10924 } 10925 10926 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10927 err = awsRestxml_deserializeDocumentInvalidKeySigningKeyName(&output, decoder) 10928 if err != nil { 10929 var snapshot bytes.Buffer 10930 io.Copy(&snapshot, ringBuffer) 10931 return &smithy.DeserializationError{ 10932 Err: fmt.Errorf("failed to decode response body, %w", err), 10933 Snapshot: snapshot.Bytes(), 10934 } 10935 } 10936 10937 return output 10938} 10939 10940func awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10941 output := &types.InvalidKeySigningKeyStatus{} 10942 var buff [1024]byte 10943 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10944 body := io.TeeReader(errorBody, ringBuffer) 10945 rootDecoder := xml.NewDecoder(body) 10946 t, err := smithyxml.FetchRootElement(rootDecoder) 10947 if err == io.EOF { 10948 return output 10949 } 10950 if err != nil { 10951 var snapshot bytes.Buffer 10952 io.Copy(&snapshot, ringBuffer) 10953 return &smithy.DeserializationError{ 10954 Err: fmt.Errorf("failed to decode response body, %w", err), 10955 Snapshot: snapshot.Bytes(), 10956 } 10957 } 10958 10959 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10960 t, err = decoder.GetElement("Error") 10961 if err != nil { 10962 var snapshot bytes.Buffer 10963 io.Copy(&snapshot, ringBuffer) 10964 return &smithy.DeserializationError{ 10965 Err: fmt.Errorf("failed to decode response body, %w", err), 10966 Snapshot: snapshot.Bytes(), 10967 } 10968 } 10969 10970 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10971 err = awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(&output, decoder) 10972 if err != nil { 10973 var snapshot bytes.Buffer 10974 io.Copy(&snapshot, ringBuffer) 10975 return &smithy.DeserializationError{ 10976 Err: fmt.Errorf("failed to decode response body, %w", err), 10977 Snapshot: snapshot.Bytes(), 10978 } 10979 } 10980 10981 return output 10982} 10983 10984func awsRestxml_deserializeErrorInvalidKMSArn(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10985 output := &types.InvalidKMSArn{} 10986 var buff [1024]byte 10987 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10988 body := io.TeeReader(errorBody, ringBuffer) 10989 rootDecoder := xml.NewDecoder(body) 10990 t, err := smithyxml.FetchRootElement(rootDecoder) 10991 if err == io.EOF { 10992 return output 10993 } 10994 if err != nil { 10995 var snapshot bytes.Buffer 10996 io.Copy(&snapshot, ringBuffer) 10997 return &smithy.DeserializationError{ 10998 Err: fmt.Errorf("failed to decode response body, %w", err), 10999 Snapshot: snapshot.Bytes(), 11000 } 11001 } 11002 11003 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11004 t, err = decoder.GetElement("Error") 11005 if err != nil { 11006 var snapshot bytes.Buffer 11007 io.Copy(&snapshot, ringBuffer) 11008 return &smithy.DeserializationError{ 11009 Err: fmt.Errorf("failed to decode response body, %w", err), 11010 Snapshot: snapshot.Bytes(), 11011 } 11012 } 11013 11014 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11015 err = awsRestxml_deserializeDocumentInvalidKMSArn(&output, decoder) 11016 if err != nil { 11017 var snapshot bytes.Buffer 11018 io.Copy(&snapshot, ringBuffer) 11019 return &smithy.DeserializationError{ 11020 Err: fmt.Errorf("failed to decode response body, %w", err), 11021 Snapshot: snapshot.Bytes(), 11022 } 11023 } 11024 11025 return output 11026} 11027 11028func awsRestxml_deserializeErrorInvalidPaginationToken(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11029 output := &types.InvalidPaginationToken{} 11030 var buff [1024]byte 11031 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11032 body := io.TeeReader(errorBody, ringBuffer) 11033 rootDecoder := xml.NewDecoder(body) 11034 t, err := smithyxml.FetchRootElement(rootDecoder) 11035 if err == io.EOF { 11036 return output 11037 } 11038 if err != nil { 11039 var snapshot bytes.Buffer 11040 io.Copy(&snapshot, ringBuffer) 11041 return &smithy.DeserializationError{ 11042 Err: fmt.Errorf("failed to decode response body, %w", err), 11043 Snapshot: snapshot.Bytes(), 11044 } 11045 } 11046 11047 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11048 t, err = decoder.GetElement("Error") 11049 if err != nil { 11050 var snapshot bytes.Buffer 11051 io.Copy(&snapshot, ringBuffer) 11052 return &smithy.DeserializationError{ 11053 Err: fmt.Errorf("failed to decode response body, %w", err), 11054 Snapshot: snapshot.Bytes(), 11055 } 11056 } 11057 11058 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11059 err = awsRestxml_deserializeDocumentInvalidPaginationToken(&output, decoder) 11060 if err != nil { 11061 var snapshot bytes.Buffer 11062 io.Copy(&snapshot, ringBuffer) 11063 return &smithy.DeserializationError{ 11064 Err: fmt.Errorf("failed to decode response body, %w", err), 11065 Snapshot: snapshot.Bytes(), 11066 } 11067 } 11068 11069 return output 11070} 11071 11072func awsRestxml_deserializeErrorInvalidSigningStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11073 output := &types.InvalidSigningStatus{} 11074 var buff [1024]byte 11075 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11076 body := io.TeeReader(errorBody, ringBuffer) 11077 rootDecoder := xml.NewDecoder(body) 11078 t, err := smithyxml.FetchRootElement(rootDecoder) 11079 if err == io.EOF { 11080 return output 11081 } 11082 if err != nil { 11083 var snapshot bytes.Buffer 11084 io.Copy(&snapshot, ringBuffer) 11085 return &smithy.DeserializationError{ 11086 Err: fmt.Errorf("failed to decode response body, %w", err), 11087 Snapshot: snapshot.Bytes(), 11088 } 11089 } 11090 11091 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11092 t, err = decoder.GetElement("Error") 11093 if err != nil { 11094 var snapshot bytes.Buffer 11095 io.Copy(&snapshot, ringBuffer) 11096 return &smithy.DeserializationError{ 11097 Err: fmt.Errorf("failed to decode response body, %w", err), 11098 Snapshot: snapshot.Bytes(), 11099 } 11100 } 11101 11102 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11103 err = awsRestxml_deserializeDocumentInvalidSigningStatus(&output, decoder) 11104 if err != nil { 11105 var snapshot bytes.Buffer 11106 io.Copy(&snapshot, ringBuffer) 11107 return &smithy.DeserializationError{ 11108 Err: fmt.Errorf("failed to decode response body, %w", err), 11109 Snapshot: snapshot.Bytes(), 11110 } 11111 } 11112 11113 return output 11114} 11115 11116func awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11117 output := &types.InvalidTrafficPolicyDocument{} 11118 var buff [1024]byte 11119 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11120 body := io.TeeReader(errorBody, ringBuffer) 11121 rootDecoder := xml.NewDecoder(body) 11122 t, err := smithyxml.FetchRootElement(rootDecoder) 11123 if err == io.EOF { 11124 return output 11125 } 11126 if err != nil { 11127 var snapshot bytes.Buffer 11128 io.Copy(&snapshot, ringBuffer) 11129 return &smithy.DeserializationError{ 11130 Err: fmt.Errorf("failed to decode response body, %w", err), 11131 Snapshot: snapshot.Bytes(), 11132 } 11133 } 11134 11135 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11136 t, err = decoder.GetElement("Error") 11137 if err != nil { 11138 var snapshot bytes.Buffer 11139 io.Copy(&snapshot, ringBuffer) 11140 return &smithy.DeserializationError{ 11141 Err: fmt.Errorf("failed to decode response body, %w", err), 11142 Snapshot: snapshot.Bytes(), 11143 } 11144 } 11145 11146 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11147 err = awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(&output, decoder) 11148 if err != nil { 11149 var snapshot bytes.Buffer 11150 io.Copy(&snapshot, ringBuffer) 11151 return &smithy.DeserializationError{ 11152 Err: fmt.Errorf("failed to decode response body, %w", err), 11153 Snapshot: snapshot.Bytes(), 11154 } 11155 } 11156 11157 return output 11158} 11159 11160func awsRestxml_deserializeErrorInvalidVPCId(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11161 output := &types.InvalidVPCId{} 11162 var buff [1024]byte 11163 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11164 body := io.TeeReader(errorBody, ringBuffer) 11165 rootDecoder := xml.NewDecoder(body) 11166 t, err := smithyxml.FetchRootElement(rootDecoder) 11167 if err == io.EOF { 11168 return output 11169 } 11170 if err != nil { 11171 var snapshot bytes.Buffer 11172 io.Copy(&snapshot, ringBuffer) 11173 return &smithy.DeserializationError{ 11174 Err: fmt.Errorf("failed to decode response body, %w", err), 11175 Snapshot: snapshot.Bytes(), 11176 } 11177 } 11178 11179 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11180 t, err = decoder.GetElement("Error") 11181 if err != nil { 11182 var snapshot bytes.Buffer 11183 io.Copy(&snapshot, ringBuffer) 11184 return &smithy.DeserializationError{ 11185 Err: fmt.Errorf("failed to decode response body, %w", err), 11186 Snapshot: snapshot.Bytes(), 11187 } 11188 } 11189 11190 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11191 err = awsRestxml_deserializeDocumentInvalidVPCId(&output, decoder) 11192 if err != nil { 11193 var snapshot bytes.Buffer 11194 io.Copy(&snapshot, ringBuffer) 11195 return &smithy.DeserializationError{ 11196 Err: fmt.Errorf("failed to decode response body, %w", err), 11197 Snapshot: snapshot.Bytes(), 11198 } 11199 } 11200 11201 return output 11202} 11203 11204func awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11205 output := &types.KeySigningKeyAlreadyExists{} 11206 var buff [1024]byte 11207 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11208 body := io.TeeReader(errorBody, ringBuffer) 11209 rootDecoder := xml.NewDecoder(body) 11210 t, err := smithyxml.FetchRootElement(rootDecoder) 11211 if err == io.EOF { 11212 return output 11213 } 11214 if err != nil { 11215 var snapshot bytes.Buffer 11216 io.Copy(&snapshot, ringBuffer) 11217 return &smithy.DeserializationError{ 11218 Err: fmt.Errorf("failed to decode response body, %w", err), 11219 Snapshot: snapshot.Bytes(), 11220 } 11221 } 11222 11223 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11224 t, err = decoder.GetElement("Error") 11225 if err != nil { 11226 var snapshot bytes.Buffer 11227 io.Copy(&snapshot, ringBuffer) 11228 return &smithy.DeserializationError{ 11229 Err: fmt.Errorf("failed to decode response body, %w", err), 11230 Snapshot: snapshot.Bytes(), 11231 } 11232 } 11233 11234 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11235 err = awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(&output, decoder) 11236 if err != nil { 11237 var snapshot bytes.Buffer 11238 io.Copy(&snapshot, ringBuffer) 11239 return &smithy.DeserializationError{ 11240 Err: fmt.Errorf("failed to decode response body, %w", err), 11241 Snapshot: snapshot.Bytes(), 11242 } 11243 } 11244 11245 return output 11246} 11247 11248func awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11249 output := &types.KeySigningKeyInParentDSRecord{} 11250 var buff [1024]byte 11251 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11252 body := io.TeeReader(errorBody, ringBuffer) 11253 rootDecoder := xml.NewDecoder(body) 11254 t, err := smithyxml.FetchRootElement(rootDecoder) 11255 if err == io.EOF { 11256 return output 11257 } 11258 if err != nil { 11259 var snapshot bytes.Buffer 11260 io.Copy(&snapshot, ringBuffer) 11261 return &smithy.DeserializationError{ 11262 Err: fmt.Errorf("failed to decode response body, %w", err), 11263 Snapshot: snapshot.Bytes(), 11264 } 11265 } 11266 11267 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11268 t, err = decoder.GetElement("Error") 11269 if err != nil { 11270 var snapshot bytes.Buffer 11271 io.Copy(&snapshot, ringBuffer) 11272 return &smithy.DeserializationError{ 11273 Err: fmt.Errorf("failed to decode response body, %w", err), 11274 Snapshot: snapshot.Bytes(), 11275 } 11276 } 11277 11278 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11279 err = awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(&output, decoder) 11280 if err != nil { 11281 var snapshot bytes.Buffer 11282 io.Copy(&snapshot, ringBuffer) 11283 return &smithy.DeserializationError{ 11284 Err: fmt.Errorf("failed to decode response body, %w", err), 11285 Snapshot: snapshot.Bytes(), 11286 } 11287 } 11288 11289 return output 11290} 11291 11292func awsRestxml_deserializeErrorKeySigningKeyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11293 output := &types.KeySigningKeyInUse{} 11294 var buff [1024]byte 11295 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11296 body := io.TeeReader(errorBody, ringBuffer) 11297 rootDecoder := xml.NewDecoder(body) 11298 t, err := smithyxml.FetchRootElement(rootDecoder) 11299 if err == io.EOF { 11300 return output 11301 } 11302 if err != nil { 11303 var snapshot bytes.Buffer 11304 io.Copy(&snapshot, ringBuffer) 11305 return &smithy.DeserializationError{ 11306 Err: fmt.Errorf("failed to decode response body, %w", err), 11307 Snapshot: snapshot.Bytes(), 11308 } 11309 } 11310 11311 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11312 t, err = decoder.GetElement("Error") 11313 if err != nil { 11314 var snapshot bytes.Buffer 11315 io.Copy(&snapshot, ringBuffer) 11316 return &smithy.DeserializationError{ 11317 Err: fmt.Errorf("failed to decode response body, %w", err), 11318 Snapshot: snapshot.Bytes(), 11319 } 11320 } 11321 11322 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11323 err = awsRestxml_deserializeDocumentKeySigningKeyInUse(&output, decoder) 11324 if err != nil { 11325 var snapshot bytes.Buffer 11326 io.Copy(&snapshot, ringBuffer) 11327 return &smithy.DeserializationError{ 11328 Err: fmt.Errorf("failed to decode response body, %w", err), 11329 Snapshot: snapshot.Bytes(), 11330 } 11331 } 11332 11333 return output 11334} 11335 11336func awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11337 output := &types.KeySigningKeyWithActiveStatusNotFound{} 11338 var buff [1024]byte 11339 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11340 body := io.TeeReader(errorBody, ringBuffer) 11341 rootDecoder := xml.NewDecoder(body) 11342 t, err := smithyxml.FetchRootElement(rootDecoder) 11343 if err == io.EOF { 11344 return output 11345 } 11346 if err != nil { 11347 var snapshot bytes.Buffer 11348 io.Copy(&snapshot, ringBuffer) 11349 return &smithy.DeserializationError{ 11350 Err: fmt.Errorf("failed to decode response body, %w", err), 11351 Snapshot: snapshot.Bytes(), 11352 } 11353 } 11354 11355 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11356 t, err = decoder.GetElement("Error") 11357 if err != nil { 11358 var snapshot bytes.Buffer 11359 io.Copy(&snapshot, ringBuffer) 11360 return &smithy.DeserializationError{ 11361 Err: fmt.Errorf("failed to decode response body, %w", err), 11362 Snapshot: snapshot.Bytes(), 11363 } 11364 } 11365 11366 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11367 err = awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(&output, decoder) 11368 if err != nil { 11369 var snapshot bytes.Buffer 11370 io.Copy(&snapshot, ringBuffer) 11371 return &smithy.DeserializationError{ 11372 Err: fmt.Errorf("failed to decode response body, %w", err), 11373 Snapshot: snapshot.Bytes(), 11374 } 11375 } 11376 11377 return output 11378} 11379 11380func awsRestxml_deserializeErrorLastVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11381 output := &types.LastVPCAssociation{} 11382 var buff [1024]byte 11383 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11384 body := io.TeeReader(errorBody, ringBuffer) 11385 rootDecoder := xml.NewDecoder(body) 11386 t, err := smithyxml.FetchRootElement(rootDecoder) 11387 if err == io.EOF { 11388 return output 11389 } 11390 if err != nil { 11391 var snapshot bytes.Buffer 11392 io.Copy(&snapshot, ringBuffer) 11393 return &smithy.DeserializationError{ 11394 Err: fmt.Errorf("failed to decode response body, %w", err), 11395 Snapshot: snapshot.Bytes(), 11396 } 11397 } 11398 11399 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11400 t, err = decoder.GetElement("Error") 11401 if err != nil { 11402 var snapshot bytes.Buffer 11403 io.Copy(&snapshot, ringBuffer) 11404 return &smithy.DeserializationError{ 11405 Err: fmt.Errorf("failed to decode response body, %w", err), 11406 Snapshot: snapshot.Bytes(), 11407 } 11408 } 11409 11410 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11411 err = awsRestxml_deserializeDocumentLastVPCAssociation(&output, decoder) 11412 if err != nil { 11413 var snapshot bytes.Buffer 11414 io.Copy(&snapshot, ringBuffer) 11415 return &smithy.DeserializationError{ 11416 Err: fmt.Errorf("failed to decode response body, %w", err), 11417 Snapshot: snapshot.Bytes(), 11418 } 11419 } 11420 11421 return output 11422} 11423 11424func awsRestxml_deserializeErrorLimitsExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11425 output := &types.LimitsExceeded{} 11426 var buff [1024]byte 11427 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11428 body := io.TeeReader(errorBody, ringBuffer) 11429 rootDecoder := xml.NewDecoder(body) 11430 t, err := smithyxml.FetchRootElement(rootDecoder) 11431 if err == io.EOF { 11432 return output 11433 } 11434 if err != nil { 11435 var snapshot bytes.Buffer 11436 io.Copy(&snapshot, ringBuffer) 11437 return &smithy.DeserializationError{ 11438 Err: fmt.Errorf("failed to decode response body, %w", err), 11439 Snapshot: snapshot.Bytes(), 11440 } 11441 } 11442 11443 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11444 t, err = decoder.GetElement("Error") 11445 if err != nil { 11446 var snapshot bytes.Buffer 11447 io.Copy(&snapshot, ringBuffer) 11448 return &smithy.DeserializationError{ 11449 Err: fmt.Errorf("failed to decode response body, %w", err), 11450 Snapshot: snapshot.Bytes(), 11451 } 11452 } 11453 11454 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11455 err = awsRestxml_deserializeDocumentLimitsExceeded(&output, decoder) 11456 if err != nil { 11457 var snapshot bytes.Buffer 11458 io.Copy(&snapshot, ringBuffer) 11459 return &smithy.DeserializationError{ 11460 Err: fmt.Errorf("failed to decode response body, %w", err), 11461 Snapshot: snapshot.Bytes(), 11462 } 11463 } 11464 11465 return output 11466} 11467 11468func awsRestxml_deserializeErrorNoSuchChange(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11469 output := &types.NoSuchChange{} 11470 var buff [1024]byte 11471 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11472 body := io.TeeReader(errorBody, ringBuffer) 11473 rootDecoder := xml.NewDecoder(body) 11474 t, err := smithyxml.FetchRootElement(rootDecoder) 11475 if err == io.EOF { 11476 return output 11477 } 11478 if err != nil { 11479 var snapshot bytes.Buffer 11480 io.Copy(&snapshot, ringBuffer) 11481 return &smithy.DeserializationError{ 11482 Err: fmt.Errorf("failed to decode response body, %w", err), 11483 Snapshot: snapshot.Bytes(), 11484 } 11485 } 11486 11487 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11488 t, err = decoder.GetElement("Error") 11489 if err != nil { 11490 var snapshot bytes.Buffer 11491 io.Copy(&snapshot, ringBuffer) 11492 return &smithy.DeserializationError{ 11493 Err: fmt.Errorf("failed to decode response body, %w", err), 11494 Snapshot: snapshot.Bytes(), 11495 } 11496 } 11497 11498 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11499 err = awsRestxml_deserializeDocumentNoSuchChange(&output, decoder) 11500 if err != nil { 11501 var snapshot bytes.Buffer 11502 io.Copy(&snapshot, ringBuffer) 11503 return &smithy.DeserializationError{ 11504 Err: fmt.Errorf("failed to decode response body, %w", err), 11505 Snapshot: snapshot.Bytes(), 11506 } 11507 } 11508 11509 return output 11510} 11511 11512func awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11513 output := &types.NoSuchCloudWatchLogsLogGroup{} 11514 var buff [1024]byte 11515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11516 body := io.TeeReader(errorBody, ringBuffer) 11517 rootDecoder := xml.NewDecoder(body) 11518 t, err := smithyxml.FetchRootElement(rootDecoder) 11519 if err == io.EOF { 11520 return output 11521 } 11522 if err != nil { 11523 var snapshot bytes.Buffer 11524 io.Copy(&snapshot, ringBuffer) 11525 return &smithy.DeserializationError{ 11526 Err: fmt.Errorf("failed to decode response body, %w", err), 11527 Snapshot: snapshot.Bytes(), 11528 } 11529 } 11530 11531 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11532 t, err = decoder.GetElement("Error") 11533 if err != nil { 11534 var snapshot bytes.Buffer 11535 io.Copy(&snapshot, ringBuffer) 11536 return &smithy.DeserializationError{ 11537 Err: fmt.Errorf("failed to decode response body, %w", err), 11538 Snapshot: snapshot.Bytes(), 11539 } 11540 } 11541 11542 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11543 err = awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(&output, decoder) 11544 if err != nil { 11545 var snapshot bytes.Buffer 11546 io.Copy(&snapshot, ringBuffer) 11547 return &smithy.DeserializationError{ 11548 Err: fmt.Errorf("failed to decode response body, %w", err), 11549 Snapshot: snapshot.Bytes(), 11550 } 11551 } 11552 11553 return output 11554} 11555 11556func awsRestxml_deserializeErrorNoSuchDelegationSet(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11557 output := &types.NoSuchDelegationSet{} 11558 var buff [1024]byte 11559 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11560 body := io.TeeReader(errorBody, ringBuffer) 11561 rootDecoder := xml.NewDecoder(body) 11562 t, err := smithyxml.FetchRootElement(rootDecoder) 11563 if err == io.EOF { 11564 return output 11565 } 11566 if err != nil { 11567 var snapshot bytes.Buffer 11568 io.Copy(&snapshot, ringBuffer) 11569 return &smithy.DeserializationError{ 11570 Err: fmt.Errorf("failed to decode response body, %w", err), 11571 Snapshot: snapshot.Bytes(), 11572 } 11573 } 11574 11575 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11576 t, err = decoder.GetElement("Error") 11577 if err != nil { 11578 var snapshot bytes.Buffer 11579 io.Copy(&snapshot, ringBuffer) 11580 return &smithy.DeserializationError{ 11581 Err: fmt.Errorf("failed to decode response body, %w", err), 11582 Snapshot: snapshot.Bytes(), 11583 } 11584 } 11585 11586 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11587 err = awsRestxml_deserializeDocumentNoSuchDelegationSet(&output, decoder) 11588 if err != nil { 11589 var snapshot bytes.Buffer 11590 io.Copy(&snapshot, ringBuffer) 11591 return &smithy.DeserializationError{ 11592 Err: fmt.Errorf("failed to decode response body, %w", err), 11593 Snapshot: snapshot.Bytes(), 11594 } 11595 } 11596 11597 return output 11598} 11599 11600func awsRestxml_deserializeErrorNoSuchGeoLocation(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11601 output := &types.NoSuchGeoLocation{} 11602 var buff [1024]byte 11603 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11604 body := io.TeeReader(errorBody, ringBuffer) 11605 rootDecoder := xml.NewDecoder(body) 11606 t, err := smithyxml.FetchRootElement(rootDecoder) 11607 if err == io.EOF { 11608 return output 11609 } 11610 if err != nil { 11611 var snapshot bytes.Buffer 11612 io.Copy(&snapshot, ringBuffer) 11613 return &smithy.DeserializationError{ 11614 Err: fmt.Errorf("failed to decode response body, %w", err), 11615 Snapshot: snapshot.Bytes(), 11616 } 11617 } 11618 11619 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11620 t, err = decoder.GetElement("Error") 11621 if err != nil { 11622 var snapshot bytes.Buffer 11623 io.Copy(&snapshot, ringBuffer) 11624 return &smithy.DeserializationError{ 11625 Err: fmt.Errorf("failed to decode response body, %w", err), 11626 Snapshot: snapshot.Bytes(), 11627 } 11628 } 11629 11630 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11631 err = awsRestxml_deserializeDocumentNoSuchGeoLocation(&output, decoder) 11632 if err != nil { 11633 var snapshot bytes.Buffer 11634 io.Copy(&snapshot, ringBuffer) 11635 return &smithy.DeserializationError{ 11636 Err: fmt.Errorf("failed to decode response body, %w", err), 11637 Snapshot: snapshot.Bytes(), 11638 } 11639 } 11640 11641 return output 11642} 11643 11644func awsRestxml_deserializeErrorNoSuchHealthCheck(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11645 output := &types.NoSuchHealthCheck{} 11646 var buff [1024]byte 11647 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11648 body := io.TeeReader(errorBody, ringBuffer) 11649 rootDecoder := xml.NewDecoder(body) 11650 t, err := smithyxml.FetchRootElement(rootDecoder) 11651 if err == io.EOF { 11652 return output 11653 } 11654 if err != nil { 11655 var snapshot bytes.Buffer 11656 io.Copy(&snapshot, ringBuffer) 11657 return &smithy.DeserializationError{ 11658 Err: fmt.Errorf("failed to decode response body, %w", err), 11659 Snapshot: snapshot.Bytes(), 11660 } 11661 } 11662 11663 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11664 t, err = decoder.GetElement("Error") 11665 if err != nil { 11666 var snapshot bytes.Buffer 11667 io.Copy(&snapshot, ringBuffer) 11668 return &smithy.DeserializationError{ 11669 Err: fmt.Errorf("failed to decode response body, %w", err), 11670 Snapshot: snapshot.Bytes(), 11671 } 11672 } 11673 11674 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11675 err = awsRestxml_deserializeDocumentNoSuchHealthCheck(&output, decoder) 11676 if err != nil { 11677 var snapshot bytes.Buffer 11678 io.Copy(&snapshot, ringBuffer) 11679 return &smithy.DeserializationError{ 11680 Err: fmt.Errorf("failed to decode response body, %w", err), 11681 Snapshot: snapshot.Bytes(), 11682 } 11683 } 11684 11685 return output 11686} 11687 11688func awsRestxml_deserializeErrorNoSuchHostedZone(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11689 output := &types.NoSuchHostedZone{} 11690 var buff [1024]byte 11691 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11692 body := io.TeeReader(errorBody, ringBuffer) 11693 rootDecoder := xml.NewDecoder(body) 11694 t, err := smithyxml.FetchRootElement(rootDecoder) 11695 if err == io.EOF { 11696 return output 11697 } 11698 if err != nil { 11699 var snapshot bytes.Buffer 11700 io.Copy(&snapshot, ringBuffer) 11701 return &smithy.DeserializationError{ 11702 Err: fmt.Errorf("failed to decode response body, %w", err), 11703 Snapshot: snapshot.Bytes(), 11704 } 11705 } 11706 11707 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11708 t, err = decoder.GetElement("Error") 11709 if err != nil { 11710 var snapshot bytes.Buffer 11711 io.Copy(&snapshot, ringBuffer) 11712 return &smithy.DeserializationError{ 11713 Err: fmt.Errorf("failed to decode response body, %w", err), 11714 Snapshot: snapshot.Bytes(), 11715 } 11716 } 11717 11718 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11719 err = awsRestxml_deserializeDocumentNoSuchHostedZone(&output, decoder) 11720 if err != nil { 11721 var snapshot bytes.Buffer 11722 io.Copy(&snapshot, ringBuffer) 11723 return &smithy.DeserializationError{ 11724 Err: fmt.Errorf("failed to decode response body, %w", err), 11725 Snapshot: snapshot.Bytes(), 11726 } 11727 } 11728 11729 return output 11730} 11731 11732func awsRestxml_deserializeErrorNoSuchKeySigningKey(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11733 output := &types.NoSuchKeySigningKey{} 11734 var buff [1024]byte 11735 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11736 body := io.TeeReader(errorBody, ringBuffer) 11737 rootDecoder := xml.NewDecoder(body) 11738 t, err := smithyxml.FetchRootElement(rootDecoder) 11739 if err == io.EOF { 11740 return output 11741 } 11742 if err != nil { 11743 var snapshot bytes.Buffer 11744 io.Copy(&snapshot, ringBuffer) 11745 return &smithy.DeserializationError{ 11746 Err: fmt.Errorf("failed to decode response body, %w", err), 11747 Snapshot: snapshot.Bytes(), 11748 } 11749 } 11750 11751 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11752 t, err = decoder.GetElement("Error") 11753 if err != nil { 11754 var snapshot bytes.Buffer 11755 io.Copy(&snapshot, ringBuffer) 11756 return &smithy.DeserializationError{ 11757 Err: fmt.Errorf("failed to decode response body, %w", err), 11758 Snapshot: snapshot.Bytes(), 11759 } 11760 } 11761 11762 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11763 err = awsRestxml_deserializeDocumentNoSuchKeySigningKey(&output, decoder) 11764 if err != nil { 11765 var snapshot bytes.Buffer 11766 io.Copy(&snapshot, ringBuffer) 11767 return &smithy.DeserializationError{ 11768 Err: fmt.Errorf("failed to decode response body, %w", err), 11769 Snapshot: snapshot.Bytes(), 11770 } 11771 } 11772 11773 return output 11774} 11775 11776func awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11777 output := &types.NoSuchQueryLoggingConfig{} 11778 var buff [1024]byte 11779 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11780 body := io.TeeReader(errorBody, ringBuffer) 11781 rootDecoder := xml.NewDecoder(body) 11782 t, err := smithyxml.FetchRootElement(rootDecoder) 11783 if err == io.EOF { 11784 return output 11785 } 11786 if err != nil { 11787 var snapshot bytes.Buffer 11788 io.Copy(&snapshot, ringBuffer) 11789 return &smithy.DeserializationError{ 11790 Err: fmt.Errorf("failed to decode response body, %w", err), 11791 Snapshot: snapshot.Bytes(), 11792 } 11793 } 11794 11795 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11796 t, err = decoder.GetElement("Error") 11797 if err != nil { 11798 var snapshot bytes.Buffer 11799 io.Copy(&snapshot, ringBuffer) 11800 return &smithy.DeserializationError{ 11801 Err: fmt.Errorf("failed to decode response body, %w", err), 11802 Snapshot: snapshot.Bytes(), 11803 } 11804 } 11805 11806 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11807 err = awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(&output, decoder) 11808 if err != nil { 11809 var snapshot bytes.Buffer 11810 io.Copy(&snapshot, ringBuffer) 11811 return &smithy.DeserializationError{ 11812 Err: fmt.Errorf("failed to decode response body, %w", err), 11813 Snapshot: snapshot.Bytes(), 11814 } 11815 } 11816 11817 return output 11818} 11819 11820func awsRestxml_deserializeErrorNoSuchTrafficPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11821 output := &types.NoSuchTrafficPolicy{} 11822 var buff [1024]byte 11823 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11824 body := io.TeeReader(errorBody, ringBuffer) 11825 rootDecoder := xml.NewDecoder(body) 11826 t, err := smithyxml.FetchRootElement(rootDecoder) 11827 if err == io.EOF { 11828 return output 11829 } 11830 if err != nil { 11831 var snapshot bytes.Buffer 11832 io.Copy(&snapshot, ringBuffer) 11833 return &smithy.DeserializationError{ 11834 Err: fmt.Errorf("failed to decode response body, %w", err), 11835 Snapshot: snapshot.Bytes(), 11836 } 11837 } 11838 11839 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11840 t, err = decoder.GetElement("Error") 11841 if err != nil { 11842 var snapshot bytes.Buffer 11843 io.Copy(&snapshot, ringBuffer) 11844 return &smithy.DeserializationError{ 11845 Err: fmt.Errorf("failed to decode response body, %w", err), 11846 Snapshot: snapshot.Bytes(), 11847 } 11848 } 11849 11850 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11851 err = awsRestxml_deserializeDocumentNoSuchTrafficPolicy(&output, decoder) 11852 if err != nil { 11853 var snapshot bytes.Buffer 11854 io.Copy(&snapshot, ringBuffer) 11855 return &smithy.DeserializationError{ 11856 Err: fmt.Errorf("failed to decode response body, %w", err), 11857 Snapshot: snapshot.Bytes(), 11858 } 11859 } 11860 11861 return output 11862} 11863 11864func awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11865 output := &types.NoSuchTrafficPolicyInstance{} 11866 var buff [1024]byte 11867 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11868 body := io.TeeReader(errorBody, ringBuffer) 11869 rootDecoder := xml.NewDecoder(body) 11870 t, err := smithyxml.FetchRootElement(rootDecoder) 11871 if err == io.EOF { 11872 return output 11873 } 11874 if err != nil { 11875 var snapshot bytes.Buffer 11876 io.Copy(&snapshot, ringBuffer) 11877 return &smithy.DeserializationError{ 11878 Err: fmt.Errorf("failed to decode response body, %w", err), 11879 Snapshot: snapshot.Bytes(), 11880 } 11881 } 11882 11883 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11884 t, err = decoder.GetElement("Error") 11885 if err != nil { 11886 var snapshot bytes.Buffer 11887 io.Copy(&snapshot, ringBuffer) 11888 return &smithy.DeserializationError{ 11889 Err: fmt.Errorf("failed to decode response body, %w", err), 11890 Snapshot: snapshot.Bytes(), 11891 } 11892 } 11893 11894 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11895 err = awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(&output, decoder) 11896 if err != nil { 11897 var snapshot bytes.Buffer 11898 io.Copy(&snapshot, ringBuffer) 11899 return &smithy.DeserializationError{ 11900 Err: fmt.Errorf("failed to decode response body, %w", err), 11901 Snapshot: snapshot.Bytes(), 11902 } 11903 } 11904 11905 return output 11906} 11907 11908func awsRestxml_deserializeErrorNotAuthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11909 output := &types.NotAuthorizedException{} 11910 var buff [1024]byte 11911 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11912 body := io.TeeReader(errorBody, ringBuffer) 11913 rootDecoder := xml.NewDecoder(body) 11914 t, err := smithyxml.FetchRootElement(rootDecoder) 11915 if err == io.EOF { 11916 return output 11917 } 11918 if err != nil { 11919 var snapshot bytes.Buffer 11920 io.Copy(&snapshot, ringBuffer) 11921 return &smithy.DeserializationError{ 11922 Err: fmt.Errorf("failed to decode response body, %w", err), 11923 Snapshot: snapshot.Bytes(), 11924 } 11925 } 11926 11927 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11928 t, err = decoder.GetElement("Error") 11929 if err != nil { 11930 var snapshot bytes.Buffer 11931 io.Copy(&snapshot, ringBuffer) 11932 return &smithy.DeserializationError{ 11933 Err: fmt.Errorf("failed to decode response body, %w", err), 11934 Snapshot: snapshot.Bytes(), 11935 } 11936 } 11937 11938 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11939 err = awsRestxml_deserializeDocumentNotAuthorizedException(&output, decoder) 11940 if err != nil { 11941 var snapshot bytes.Buffer 11942 io.Copy(&snapshot, ringBuffer) 11943 return &smithy.DeserializationError{ 11944 Err: fmt.Errorf("failed to decode response body, %w", err), 11945 Snapshot: snapshot.Bytes(), 11946 } 11947 } 11948 11949 return output 11950} 11951 11952func awsRestxml_deserializeErrorPriorRequestNotComplete(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11953 output := &types.PriorRequestNotComplete{} 11954 var buff [1024]byte 11955 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11956 body := io.TeeReader(errorBody, ringBuffer) 11957 rootDecoder := xml.NewDecoder(body) 11958 t, err := smithyxml.FetchRootElement(rootDecoder) 11959 if err == io.EOF { 11960 return output 11961 } 11962 if err != nil { 11963 var snapshot bytes.Buffer 11964 io.Copy(&snapshot, ringBuffer) 11965 return &smithy.DeserializationError{ 11966 Err: fmt.Errorf("failed to decode response body, %w", err), 11967 Snapshot: snapshot.Bytes(), 11968 } 11969 } 11970 11971 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11972 t, err = decoder.GetElement("Error") 11973 if err != nil { 11974 var snapshot bytes.Buffer 11975 io.Copy(&snapshot, ringBuffer) 11976 return &smithy.DeserializationError{ 11977 Err: fmt.Errorf("failed to decode response body, %w", err), 11978 Snapshot: snapshot.Bytes(), 11979 } 11980 } 11981 11982 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11983 err = awsRestxml_deserializeDocumentPriorRequestNotComplete(&output, decoder) 11984 if err != nil { 11985 var snapshot bytes.Buffer 11986 io.Copy(&snapshot, ringBuffer) 11987 return &smithy.DeserializationError{ 11988 Err: fmt.Errorf("failed to decode response body, %w", err), 11989 Snapshot: snapshot.Bytes(), 11990 } 11991 } 11992 11993 return output 11994} 11995 11996func awsRestxml_deserializeErrorPublicZoneVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11997 output := &types.PublicZoneVPCAssociation{} 11998 var buff [1024]byte 11999 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12000 body := io.TeeReader(errorBody, ringBuffer) 12001 rootDecoder := xml.NewDecoder(body) 12002 t, err := smithyxml.FetchRootElement(rootDecoder) 12003 if err == io.EOF { 12004 return output 12005 } 12006 if err != nil { 12007 var snapshot bytes.Buffer 12008 io.Copy(&snapshot, ringBuffer) 12009 return &smithy.DeserializationError{ 12010 Err: fmt.Errorf("failed to decode response body, %w", err), 12011 Snapshot: snapshot.Bytes(), 12012 } 12013 } 12014 12015 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12016 t, err = decoder.GetElement("Error") 12017 if err != nil { 12018 var snapshot bytes.Buffer 12019 io.Copy(&snapshot, ringBuffer) 12020 return &smithy.DeserializationError{ 12021 Err: fmt.Errorf("failed to decode response body, %w", err), 12022 Snapshot: snapshot.Bytes(), 12023 } 12024 } 12025 12026 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12027 err = awsRestxml_deserializeDocumentPublicZoneVPCAssociation(&output, decoder) 12028 if err != nil { 12029 var snapshot bytes.Buffer 12030 io.Copy(&snapshot, ringBuffer) 12031 return &smithy.DeserializationError{ 12032 Err: fmt.Errorf("failed to decode response body, %w", err), 12033 Snapshot: snapshot.Bytes(), 12034 } 12035 } 12036 12037 return output 12038} 12039 12040func awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12041 output := &types.QueryLoggingConfigAlreadyExists{} 12042 var buff [1024]byte 12043 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12044 body := io.TeeReader(errorBody, ringBuffer) 12045 rootDecoder := xml.NewDecoder(body) 12046 t, err := smithyxml.FetchRootElement(rootDecoder) 12047 if err == io.EOF { 12048 return output 12049 } 12050 if err != nil { 12051 var snapshot bytes.Buffer 12052 io.Copy(&snapshot, ringBuffer) 12053 return &smithy.DeserializationError{ 12054 Err: fmt.Errorf("failed to decode response body, %w", err), 12055 Snapshot: snapshot.Bytes(), 12056 } 12057 } 12058 12059 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12060 t, err = decoder.GetElement("Error") 12061 if err != nil { 12062 var snapshot bytes.Buffer 12063 io.Copy(&snapshot, ringBuffer) 12064 return &smithy.DeserializationError{ 12065 Err: fmt.Errorf("failed to decode response body, %w", err), 12066 Snapshot: snapshot.Bytes(), 12067 } 12068 } 12069 12070 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12071 err = awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(&output, decoder) 12072 if err != nil { 12073 var snapshot bytes.Buffer 12074 io.Copy(&snapshot, ringBuffer) 12075 return &smithy.DeserializationError{ 12076 Err: fmt.Errorf("failed to decode response body, %w", err), 12077 Snapshot: snapshot.Bytes(), 12078 } 12079 } 12080 12081 return output 12082} 12083 12084func awsRestxml_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12085 output := &types.ThrottlingException{} 12086 var buff [1024]byte 12087 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12088 body := io.TeeReader(errorBody, ringBuffer) 12089 rootDecoder := xml.NewDecoder(body) 12090 t, err := smithyxml.FetchRootElement(rootDecoder) 12091 if err == io.EOF { 12092 return output 12093 } 12094 if err != nil { 12095 var snapshot bytes.Buffer 12096 io.Copy(&snapshot, ringBuffer) 12097 return &smithy.DeserializationError{ 12098 Err: fmt.Errorf("failed to decode response body, %w", err), 12099 Snapshot: snapshot.Bytes(), 12100 } 12101 } 12102 12103 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12104 t, err = decoder.GetElement("Error") 12105 if err != nil { 12106 var snapshot bytes.Buffer 12107 io.Copy(&snapshot, ringBuffer) 12108 return &smithy.DeserializationError{ 12109 Err: fmt.Errorf("failed to decode response body, %w", err), 12110 Snapshot: snapshot.Bytes(), 12111 } 12112 } 12113 12114 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12115 err = awsRestxml_deserializeDocumentThrottlingException(&output, decoder) 12116 if err != nil { 12117 var snapshot bytes.Buffer 12118 io.Copy(&snapshot, ringBuffer) 12119 return &smithy.DeserializationError{ 12120 Err: fmt.Errorf("failed to decode response body, %w", err), 12121 Snapshot: snapshot.Bytes(), 12122 } 12123 } 12124 12125 return output 12126} 12127 12128func awsRestxml_deserializeErrorTooManyHealthChecks(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12129 output := &types.TooManyHealthChecks{} 12130 var buff [1024]byte 12131 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12132 body := io.TeeReader(errorBody, ringBuffer) 12133 rootDecoder := xml.NewDecoder(body) 12134 t, err := smithyxml.FetchRootElement(rootDecoder) 12135 if err == io.EOF { 12136 return output 12137 } 12138 if err != nil { 12139 var snapshot bytes.Buffer 12140 io.Copy(&snapshot, ringBuffer) 12141 return &smithy.DeserializationError{ 12142 Err: fmt.Errorf("failed to decode response body, %w", err), 12143 Snapshot: snapshot.Bytes(), 12144 } 12145 } 12146 12147 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12148 t, err = decoder.GetElement("Error") 12149 if err != nil { 12150 var snapshot bytes.Buffer 12151 io.Copy(&snapshot, ringBuffer) 12152 return &smithy.DeserializationError{ 12153 Err: fmt.Errorf("failed to decode response body, %w", err), 12154 Snapshot: snapshot.Bytes(), 12155 } 12156 } 12157 12158 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12159 err = awsRestxml_deserializeDocumentTooManyHealthChecks(&output, decoder) 12160 if err != nil { 12161 var snapshot bytes.Buffer 12162 io.Copy(&snapshot, ringBuffer) 12163 return &smithy.DeserializationError{ 12164 Err: fmt.Errorf("failed to decode response body, %w", err), 12165 Snapshot: snapshot.Bytes(), 12166 } 12167 } 12168 12169 return output 12170} 12171 12172func awsRestxml_deserializeErrorTooManyHostedZones(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12173 output := &types.TooManyHostedZones{} 12174 var buff [1024]byte 12175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12176 body := io.TeeReader(errorBody, ringBuffer) 12177 rootDecoder := xml.NewDecoder(body) 12178 t, err := smithyxml.FetchRootElement(rootDecoder) 12179 if err == io.EOF { 12180 return output 12181 } 12182 if err != nil { 12183 var snapshot bytes.Buffer 12184 io.Copy(&snapshot, ringBuffer) 12185 return &smithy.DeserializationError{ 12186 Err: fmt.Errorf("failed to decode response body, %w", err), 12187 Snapshot: snapshot.Bytes(), 12188 } 12189 } 12190 12191 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12192 t, err = decoder.GetElement("Error") 12193 if err != nil { 12194 var snapshot bytes.Buffer 12195 io.Copy(&snapshot, ringBuffer) 12196 return &smithy.DeserializationError{ 12197 Err: fmt.Errorf("failed to decode response body, %w", err), 12198 Snapshot: snapshot.Bytes(), 12199 } 12200 } 12201 12202 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12203 err = awsRestxml_deserializeDocumentTooManyHostedZones(&output, decoder) 12204 if err != nil { 12205 var snapshot bytes.Buffer 12206 io.Copy(&snapshot, ringBuffer) 12207 return &smithy.DeserializationError{ 12208 Err: fmt.Errorf("failed to decode response body, %w", err), 12209 Snapshot: snapshot.Bytes(), 12210 } 12211 } 12212 12213 return output 12214} 12215 12216func awsRestxml_deserializeErrorTooManyKeySigningKeys(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12217 output := &types.TooManyKeySigningKeys{} 12218 var buff [1024]byte 12219 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12220 body := io.TeeReader(errorBody, ringBuffer) 12221 rootDecoder := xml.NewDecoder(body) 12222 t, err := smithyxml.FetchRootElement(rootDecoder) 12223 if err == io.EOF { 12224 return output 12225 } 12226 if err != nil { 12227 var snapshot bytes.Buffer 12228 io.Copy(&snapshot, ringBuffer) 12229 return &smithy.DeserializationError{ 12230 Err: fmt.Errorf("failed to decode response body, %w", err), 12231 Snapshot: snapshot.Bytes(), 12232 } 12233 } 12234 12235 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12236 t, err = decoder.GetElement("Error") 12237 if err != nil { 12238 var snapshot bytes.Buffer 12239 io.Copy(&snapshot, ringBuffer) 12240 return &smithy.DeserializationError{ 12241 Err: fmt.Errorf("failed to decode response body, %w", err), 12242 Snapshot: snapshot.Bytes(), 12243 } 12244 } 12245 12246 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12247 err = awsRestxml_deserializeDocumentTooManyKeySigningKeys(&output, decoder) 12248 if err != nil { 12249 var snapshot bytes.Buffer 12250 io.Copy(&snapshot, ringBuffer) 12251 return &smithy.DeserializationError{ 12252 Err: fmt.Errorf("failed to decode response body, %w", err), 12253 Snapshot: snapshot.Bytes(), 12254 } 12255 } 12256 12257 return output 12258} 12259 12260func awsRestxml_deserializeErrorTooManyTrafficPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12261 output := &types.TooManyTrafficPolicies{} 12262 var buff [1024]byte 12263 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12264 body := io.TeeReader(errorBody, ringBuffer) 12265 rootDecoder := xml.NewDecoder(body) 12266 t, err := smithyxml.FetchRootElement(rootDecoder) 12267 if err == io.EOF { 12268 return output 12269 } 12270 if err != nil { 12271 var snapshot bytes.Buffer 12272 io.Copy(&snapshot, ringBuffer) 12273 return &smithy.DeserializationError{ 12274 Err: fmt.Errorf("failed to decode response body, %w", err), 12275 Snapshot: snapshot.Bytes(), 12276 } 12277 } 12278 12279 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12280 t, err = decoder.GetElement("Error") 12281 if err != nil { 12282 var snapshot bytes.Buffer 12283 io.Copy(&snapshot, ringBuffer) 12284 return &smithy.DeserializationError{ 12285 Err: fmt.Errorf("failed to decode response body, %w", err), 12286 Snapshot: snapshot.Bytes(), 12287 } 12288 } 12289 12290 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12291 err = awsRestxml_deserializeDocumentTooManyTrafficPolicies(&output, decoder) 12292 if err != nil { 12293 var snapshot bytes.Buffer 12294 io.Copy(&snapshot, ringBuffer) 12295 return &smithy.DeserializationError{ 12296 Err: fmt.Errorf("failed to decode response body, %w", err), 12297 Snapshot: snapshot.Bytes(), 12298 } 12299 } 12300 12301 return output 12302} 12303 12304func awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12305 output := &types.TooManyTrafficPolicyInstances{} 12306 var buff [1024]byte 12307 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12308 body := io.TeeReader(errorBody, ringBuffer) 12309 rootDecoder := xml.NewDecoder(body) 12310 t, err := smithyxml.FetchRootElement(rootDecoder) 12311 if err == io.EOF { 12312 return output 12313 } 12314 if err != nil { 12315 var snapshot bytes.Buffer 12316 io.Copy(&snapshot, ringBuffer) 12317 return &smithy.DeserializationError{ 12318 Err: fmt.Errorf("failed to decode response body, %w", err), 12319 Snapshot: snapshot.Bytes(), 12320 } 12321 } 12322 12323 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12324 t, err = decoder.GetElement("Error") 12325 if err != nil { 12326 var snapshot bytes.Buffer 12327 io.Copy(&snapshot, ringBuffer) 12328 return &smithy.DeserializationError{ 12329 Err: fmt.Errorf("failed to decode response body, %w", err), 12330 Snapshot: snapshot.Bytes(), 12331 } 12332 } 12333 12334 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12335 err = awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(&output, decoder) 12336 if err != nil { 12337 var snapshot bytes.Buffer 12338 io.Copy(&snapshot, ringBuffer) 12339 return &smithy.DeserializationError{ 12340 Err: fmt.Errorf("failed to decode response body, %w", err), 12341 Snapshot: snapshot.Bytes(), 12342 } 12343 } 12344 12345 return output 12346} 12347 12348func awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12349 output := &types.TooManyTrafficPolicyVersionsForCurrentPolicy{} 12350 var buff [1024]byte 12351 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12352 body := io.TeeReader(errorBody, ringBuffer) 12353 rootDecoder := xml.NewDecoder(body) 12354 t, err := smithyxml.FetchRootElement(rootDecoder) 12355 if err == io.EOF { 12356 return output 12357 } 12358 if err != nil { 12359 var snapshot bytes.Buffer 12360 io.Copy(&snapshot, ringBuffer) 12361 return &smithy.DeserializationError{ 12362 Err: fmt.Errorf("failed to decode response body, %w", err), 12363 Snapshot: snapshot.Bytes(), 12364 } 12365 } 12366 12367 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12368 t, err = decoder.GetElement("Error") 12369 if err != nil { 12370 var snapshot bytes.Buffer 12371 io.Copy(&snapshot, ringBuffer) 12372 return &smithy.DeserializationError{ 12373 Err: fmt.Errorf("failed to decode response body, %w", err), 12374 Snapshot: snapshot.Bytes(), 12375 } 12376 } 12377 12378 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12379 err = awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(&output, decoder) 12380 if err != nil { 12381 var snapshot bytes.Buffer 12382 io.Copy(&snapshot, ringBuffer) 12383 return &smithy.DeserializationError{ 12384 Err: fmt.Errorf("failed to decode response body, %w", err), 12385 Snapshot: snapshot.Bytes(), 12386 } 12387 } 12388 12389 return output 12390} 12391 12392func awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12393 output := &types.TooManyVPCAssociationAuthorizations{} 12394 var buff [1024]byte 12395 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12396 body := io.TeeReader(errorBody, ringBuffer) 12397 rootDecoder := xml.NewDecoder(body) 12398 t, err := smithyxml.FetchRootElement(rootDecoder) 12399 if err == io.EOF { 12400 return output 12401 } 12402 if err != nil { 12403 var snapshot bytes.Buffer 12404 io.Copy(&snapshot, ringBuffer) 12405 return &smithy.DeserializationError{ 12406 Err: fmt.Errorf("failed to decode response body, %w", err), 12407 Snapshot: snapshot.Bytes(), 12408 } 12409 } 12410 12411 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12412 t, err = decoder.GetElement("Error") 12413 if err != nil { 12414 var snapshot bytes.Buffer 12415 io.Copy(&snapshot, ringBuffer) 12416 return &smithy.DeserializationError{ 12417 Err: fmt.Errorf("failed to decode response body, %w", err), 12418 Snapshot: snapshot.Bytes(), 12419 } 12420 } 12421 12422 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12423 err = awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(&output, decoder) 12424 if err != nil { 12425 var snapshot bytes.Buffer 12426 io.Copy(&snapshot, ringBuffer) 12427 return &smithy.DeserializationError{ 12428 Err: fmt.Errorf("failed to decode response body, %w", err), 12429 Snapshot: snapshot.Bytes(), 12430 } 12431 } 12432 12433 return output 12434} 12435 12436func awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12437 output := &types.TrafficPolicyAlreadyExists{} 12438 var buff [1024]byte 12439 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12440 body := io.TeeReader(errorBody, ringBuffer) 12441 rootDecoder := xml.NewDecoder(body) 12442 t, err := smithyxml.FetchRootElement(rootDecoder) 12443 if err == io.EOF { 12444 return output 12445 } 12446 if err != nil { 12447 var snapshot bytes.Buffer 12448 io.Copy(&snapshot, ringBuffer) 12449 return &smithy.DeserializationError{ 12450 Err: fmt.Errorf("failed to decode response body, %w", err), 12451 Snapshot: snapshot.Bytes(), 12452 } 12453 } 12454 12455 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12456 t, err = decoder.GetElement("Error") 12457 if err != nil { 12458 var snapshot bytes.Buffer 12459 io.Copy(&snapshot, ringBuffer) 12460 return &smithy.DeserializationError{ 12461 Err: fmt.Errorf("failed to decode response body, %w", err), 12462 Snapshot: snapshot.Bytes(), 12463 } 12464 } 12465 12466 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12467 err = awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(&output, decoder) 12468 if err != nil { 12469 var snapshot bytes.Buffer 12470 io.Copy(&snapshot, ringBuffer) 12471 return &smithy.DeserializationError{ 12472 Err: fmt.Errorf("failed to decode response body, %w", err), 12473 Snapshot: snapshot.Bytes(), 12474 } 12475 } 12476 12477 return output 12478} 12479 12480func awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12481 output := &types.TrafficPolicyInstanceAlreadyExists{} 12482 var buff [1024]byte 12483 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12484 body := io.TeeReader(errorBody, ringBuffer) 12485 rootDecoder := xml.NewDecoder(body) 12486 t, err := smithyxml.FetchRootElement(rootDecoder) 12487 if err == io.EOF { 12488 return output 12489 } 12490 if err != nil { 12491 var snapshot bytes.Buffer 12492 io.Copy(&snapshot, ringBuffer) 12493 return &smithy.DeserializationError{ 12494 Err: fmt.Errorf("failed to decode response body, %w", err), 12495 Snapshot: snapshot.Bytes(), 12496 } 12497 } 12498 12499 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12500 t, err = decoder.GetElement("Error") 12501 if err != nil { 12502 var snapshot bytes.Buffer 12503 io.Copy(&snapshot, ringBuffer) 12504 return &smithy.DeserializationError{ 12505 Err: fmt.Errorf("failed to decode response body, %w", err), 12506 Snapshot: snapshot.Bytes(), 12507 } 12508 } 12509 12510 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12511 err = awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(&output, decoder) 12512 if err != nil { 12513 var snapshot bytes.Buffer 12514 io.Copy(&snapshot, ringBuffer) 12515 return &smithy.DeserializationError{ 12516 Err: fmt.Errorf("failed to decode response body, %w", err), 12517 Snapshot: snapshot.Bytes(), 12518 } 12519 } 12520 12521 return output 12522} 12523 12524func awsRestxml_deserializeErrorTrafficPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12525 output := &types.TrafficPolicyInUse{} 12526 var buff [1024]byte 12527 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12528 body := io.TeeReader(errorBody, ringBuffer) 12529 rootDecoder := xml.NewDecoder(body) 12530 t, err := smithyxml.FetchRootElement(rootDecoder) 12531 if err == io.EOF { 12532 return output 12533 } 12534 if err != nil { 12535 var snapshot bytes.Buffer 12536 io.Copy(&snapshot, ringBuffer) 12537 return &smithy.DeserializationError{ 12538 Err: fmt.Errorf("failed to decode response body, %w", err), 12539 Snapshot: snapshot.Bytes(), 12540 } 12541 } 12542 12543 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12544 t, err = decoder.GetElement("Error") 12545 if err != nil { 12546 var snapshot bytes.Buffer 12547 io.Copy(&snapshot, ringBuffer) 12548 return &smithy.DeserializationError{ 12549 Err: fmt.Errorf("failed to decode response body, %w", err), 12550 Snapshot: snapshot.Bytes(), 12551 } 12552 } 12553 12554 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12555 err = awsRestxml_deserializeDocumentTrafficPolicyInUse(&output, decoder) 12556 if err != nil { 12557 var snapshot bytes.Buffer 12558 io.Copy(&snapshot, ringBuffer) 12559 return &smithy.DeserializationError{ 12560 Err: fmt.Errorf("failed to decode response body, %w", err), 12561 Snapshot: snapshot.Bytes(), 12562 } 12563 } 12564 12565 return output 12566} 12567 12568func awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12569 output := &types.VPCAssociationAuthorizationNotFound{} 12570 var buff [1024]byte 12571 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12572 body := io.TeeReader(errorBody, ringBuffer) 12573 rootDecoder := xml.NewDecoder(body) 12574 t, err := smithyxml.FetchRootElement(rootDecoder) 12575 if err == io.EOF { 12576 return output 12577 } 12578 if err != nil { 12579 var snapshot bytes.Buffer 12580 io.Copy(&snapshot, ringBuffer) 12581 return &smithy.DeserializationError{ 12582 Err: fmt.Errorf("failed to decode response body, %w", err), 12583 Snapshot: snapshot.Bytes(), 12584 } 12585 } 12586 12587 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12588 t, err = decoder.GetElement("Error") 12589 if err != nil { 12590 var snapshot bytes.Buffer 12591 io.Copy(&snapshot, ringBuffer) 12592 return &smithy.DeserializationError{ 12593 Err: fmt.Errorf("failed to decode response body, %w", err), 12594 Snapshot: snapshot.Bytes(), 12595 } 12596 } 12597 12598 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12599 err = awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(&output, decoder) 12600 if err != nil { 12601 var snapshot bytes.Buffer 12602 io.Copy(&snapshot, ringBuffer) 12603 return &smithy.DeserializationError{ 12604 Err: fmt.Errorf("failed to decode response body, %w", err), 12605 Snapshot: snapshot.Bytes(), 12606 } 12607 } 12608 12609 return output 12610} 12611 12612func awsRestxml_deserializeErrorVPCAssociationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12613 output := &types.VPCAssociationNotFound{} 12614 var buff [1024]byte 12615 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12616 body := io.TeeReader(errorBody, ringBuffer) 12617 rootDecoder := xml.NewDecoder(body) 12618 t, err := smithyxml.FetchRootElement(rootDecoder) 12619 if err == io.EOF { 12620 return output 12621 } 12622 if err != nil { 12623 var snapshot bytes.Buffer 12624 io.Copy(&snapshot, ringBuffer) 12625 return &smithy.DeserializationError{ 12626 Err: fmt.Errorf("failed to decode response body, %w", err), 12627 Snapshot: snapshot.Bytes(), 12628 } 12629 } 12630 12631 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12632 t, err = decoder.GetElement("Error") 12633 if err != nil { 12634 var snapshot bytes.Buffer 12635 io.Copy(&snapshot, ringBuffer) 12636 return &smithy.DeserializationError{ 12637 Err: fmt.Errorf("failed to decode response body, %w", err), 12638 Snapshot: snapshot.Bytes(), 12639 } 12640 } 12641 12642 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12643 err = awsRestxml_deserializeDocumentVPCAssociationNotFound(&output, decoder) 12644 if err != nil { 12645 var snapshot bytes.Buffer 12646 io.Copy(&snapshot, ringBuffer) 12647 return &smithy.DeserializationError{ 12648 Err: fmt.Errorf("failed to decode response body, %w", err), 12649 Snapshot: snapshot.Bytes(), 12650 } 12651 } 12652 12653 return output 12654} 12655 12656func awsRestxml_deserializeDocumentAccountLimit(v **types.AccountLimit, decoder smithyxml.NodeDecoder) error { 12657 if v == nil { 12658 return fmt.Errorf("unexpected nil of type %T", v) 12659 } 12660 var sv *types.AccountLimit 12661 if *v == nil { 12662 sv = &types.AccountLimit{} 12663 } else { 12664 sv = *v 12665 } 12666 12667 for { 12668 t, done, err := decoder.Token() 12669 if err != nil { 12670 return err 12671 } 12672 if done { 12673 break 12674 } 12675 originalDecoder := decoder 12676 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12677 switch { 12678 case strings.EqualFold("Type", t.Name.Local): 12679 val, err := decoder.Value() 12680 if err != nil { 12681 return err 12682 } 12683 if val == nil { 12684 break 12685 } 12686 { 12687 xtv := string(val) 12688 sv.Type = types.AccountLimitType(xtv) 12689 } 12690 12691 case strings.EqualFold("Value", t.Name.Local): 12692 val, err := decoder.Value() 12693 if err != nil { 12694 return err 12695 } 12696 if val == nil { 12697 break 12698 } 12699 { 12700 xtv := string(val) 12701 i64, err := strconv.ParseInt(xtv, 10, 64) 12702 if err != nil { 12703 return err 12704 } 12705 sv.Value = i64 12706 } 12707 12708 default: 12709 // Do nothing and ignore the unexpected tag element 12710 err = decoder.Decoder.Skip() 12711 if err != nil { 12712 return err 12713 } 12714 12715 } 12716 decoder = originalDecoder 12717 } 12718 *v = sv 12719 return nil 12720} 12721 12722func awsRestxml_deserializeDocumentAlarmIdentifier(v **types.AlarmIdentifier, decoder smithyxml.NodeDecoder) error { 12723 if v == nil { 12724 return fmt.Errorf("unexpected nil of type %T", v) 12725 } 12726 var sv *types.AlarmIdentifier 12727 if *v == nil { 12728 sv = &types.AlarmIdentifier{} 12729 } else { 12730 sv = *v 12731 } 12732 12733 for { 12734 t, done, err := decoder.Token() 12735 if err != nil { 12736 return err 12737 } 12738 if done { 12739 break 12740 } 12741 originalDecoder := decoder 12742 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12743 switch { 12744 case strings.EqualFold("Name", t.Name.Local): 12745 val, err := decoder.Value() 12746 if err != nil { 12747 return err 12748 } 12749 if val == nil { 12750 break 12751 } 12752 { 12753 xtv := string(val) 12754 sv.Name = ptr.String(xtv) 12755 } 12756 12757 case strings.EqualFold("Region", t.Name.Local): 12758 val, err := decoder.Value() 12759 if err != nil { 12760 return err 12761 } 12762 if val == nil { 12763 break 12764 } 12765 { 12766 xtv := string(val) 12767 sv.Region = types.CloudWatchRegion(xtv) 12768 } 12769 12770 default: 12771 // Do nothing and ignore the unexpected tag element 12772 err = decoder.Decoder.Skip() 12773 if err != nil { 12774 return err 12775 } 12776 12777 } 12778 decoder = originalDecoder 12779 } 12780 *v = sv 12781 return nil 12782} 12783 12784func awsRestxml_deserializeDocumentAliasTarget(v **types.AliasTarget, decoder smithyxml.NodeDecoder) error { 12785 if v == nil { 12786 return fmt.Errorf("unexpected nil of type %T", v) 12787 } 12788 var sv *types.AliasTarget 12789 if *v == nil { 12790 sv = &types.AliasTarget{} 12791 } else { 12792 sv = *v 12793 } 12794 12795 for { 12796 t, done, err := decoder.Token() 12797 if err != nil { 12798 return err 12799 } 12800 if done { 12801 break 12802 } 12803 originalDecoder := decoder 12804 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12805 switch { 12806 case strings.EqualFold("DNSName", t.Name.Local): 12807 val, err := decoder.Value() 12808 if err != nil { 12809 return err 12810 } 12811 if val == nil { 12812 break 12813 } 12814 { 12815 xtv := string(val) 12816 sv.DNSName = ptr.String(xtv) 12817 } 12818 12819 case strings.EqualFold("EvaluateTargetHealth", t.Name.Local): 12820 val, err := decoder.Value() 12821 if err != nil { 12822 return err 12823 } 12824 if val == nil { 12825 break 12826 } 12827 { 12828 xtv, err := strconv.ParseBool(string(val)) 12829 if err != nil { 12830 return fmt.Errorf("expected AliasHealthEnabled to be of type *bool, got %T instead", val) 12831 } 12832 sv.EvaluateTargetHealth = xtv 12833 } 12834 12835 case strings.EqualFold("HostedZoneId", t.Name.Local): 12836 val, err := decoder.Value() 12837 if err != nil { 12838 return err 12839 } 12840 if val == nil { 12841 break 12842 } 12843 { 12844 xtv := string(val) 12845 sv.HostedZoneId = ptr.String(xtv) 12846 } 12847 12848 default: 12849 // Do nothing and ignore the unexpected tag element 12850 err = decoder.Decoder.Skip() 12851 if err != nil { 12852 return err 12853 } 12854 12855 } 12856 decoder = originalDecoder 12857 } 12858 *v = sv 12859 return nil 12860} 12861 12862func awsRestxml_deserializeDocumentChangeInfo(v **types.ChangeInfo, decoder smithyxml.NodeDecoder) error { 12863 if v == nil { 12864 return fmt.Errorf("unexpected nil of type %T", v) 12865 } 12866 var sv *types.ChangeInfo 12867 if *v == nil { 12868 sv = &types.ChangeInfo{} 12869 } else { 12870 sv = *v 12871 } 12872 12873 for { 12874 t, done, err := decoder.Token() 12875 if err != nil { 12876 return err 12877 } 12878 if done { 12879 break 12880 } 12881 originalDecoder := decoder 12882 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12883 switch { 12884 case strings.EqualFold("Comment", t.Name.Local): 12885 val, err := decoder.Value() 12886 if err != nil { 12887 return err 12888 } 12889 if val == nil { 12890 break 12891 } 12892 { 12893 xtv := string(val) 12894 sv.Comment = ptr.String(xtv) 12895 } 12896 12897 case strings.EqualFold("Id", t.Name.Local): 12898 val, err := decoder.Value() 12899 if err != nil { 12900 return err 12901 } 12902 if val == nil { 12903 break 12904 } 12905 { 12906 xtv := string(val) 12907 sv.Id = ptr.String(xtv) 12908 } 12909 12910 case strings.EqualFold("Status", t.Name.Local): 12911 val, err := decoder.Value() 12912 if err != nil { 12913 return err 12914 } 12915 if val == nil { 12916 break 12917 } 12918 { 12919 xtv := string(val) 12920 sv.Status = types.ChangeStatus(xtv) 12921 } 12922 12923 case strings.EqualFold("SubmittedAt", t.Name.Local): 12924 val, err := decoder.Value() 12925 if err != nil { 12926 return err 12927 } 12928 if val == nil { 12929 break 12930 } 12931 { 12932 xtv := string(val) 12933 t, err := smithytime.ParseDateTime(xtv) 12934 if err != nil { 12935 return err 12936 } 12937 sv.SubmittedAt = ptr.Time(t) 12938 } 12939 12940 default: 12941 // Do nothing and ignore the unexpected tag element 12942 err = decoder.Decoder.Skip() 12943 if err != nil { 12944 return err 12945 } 12946 12947 } 12948 decoder = originalDecoder 12949 } 12950 *v = sv 12951 return nil 12952} 12953 12954func awsRestxml_deserializeDocumentCheckerIpRanges(v *[]string, decoder smithyxml.NodeDecoder) error { 12955 if v == nil { 12956 return fmt.Errorf("unexpected nil of type %T", v) 12957 } 12958 var sv []string 12959 if *v == nil { 12960 sv = make([]string, 0) 12961 } else { 12962 sv = *v 12963 } 12964 12965 originalDecoder := decoder 12966 for { 12967 t, done, err := decoder.Token() 12968 if err != nil { 12969 return err 12970 } 12971 if done { 12972 break 12973 } 12974 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12975 decoder = memberDecoder 12976 switch { 12977 case strings.EqualFold("member", t.Name.Local): 12978 var col string 12979 val, err := decoder.Value() 12980 if err != nil { 12981 return err 12982 } 12983 if val == nil { 12984 break 12985 } 12986 { 12987 xtv := string(val) 12988 col = xtv 12989 } 12990 sv = append(sv, col) 12991 12992 default: 12993 err = decoder.Decoder.Skip() 12994 if err != nil { 12995 return err 12996 } 12997 12998 } 12999 decoder = originalDecoder 13000 } 13001 *v = sv 13002 return nil 13003} 13004 13005func awsRestxml_deserializeDocumentCheckerIpRangesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13006 var sv []string 13007 if *v == nil { 13008 sv = make([]string, 0) 13009 } else { 13010 sv = *v 13011 } 13012 13013 switch { 13014 default: 13015 var mv string 13016 t := decoder.StartEl 13017 _ = t 13018 val, err := decoder.Value() 13019 if err != nil { 13020 return err 13021 } 13022 if val == nil { 13023 break 13024 } 13025 { 13026 xtv := string(val) 13027 mv = xtv 13028 } 13029 sv = append(sv, mv) 13030 } 13031 *v = sv 13032 return nil 13033} 13034func awsRestxml_deserializeDocumentChildHealthCheckList(v *[]string, decoder smithyxml.NodeDecoder) error { 13035 if v == nil { 13036 return fmt.Errorf("unexpected nil of type %T", v) 13037 } 13038 var sv []string 13039 if *v == nil { 13040 sv = make([]string, 0) 13041 } else { 13042 sv = *v 13043 } 13044 13045 originalDecoder := decoder 13046 for { 13047 t, done, err := decoder.Token() 13048 if err != nil { 13049 return err 13050 } 13051 if done { 13052 break 13053 } 13054 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13055 decoder = memberDecoder 13056 switch { 13057 case strings.EqualFold("ChildHealthCheck", t.Name.Local): 13058 var col string 13059 val, err := decoder.Value() 13060 if err != nil { 13061 return err 13062 } 13063 if val == nil { 13064 break 13065 } 13066 { 13067 xtv := string(val) 13068 col = xtv 13069 } 13070 sv = append(sv, col) 13071 13072 default: 13073 err = decoder.Decoder.Skip() 13074 if err != nil { 13075 return err 13076 } 13077 13078 } 13079 decoder = originalDecoder 13080 } 13081 *v = sv 13082 return nil 13083} 13084 13085func awsRestxml_deserializeDocumentChildHealthCheckListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13086 var sv []string 13087 if *v == nil { 13088 sv = make([]string, 0) 13089 } else { 13090 sv = *v 13091 } 13092 13093 switch { 13094 default: 13095 var mv string 13096 t := decoder.StartEl 13097 _ = t 13098 val, err := decoder.Value() 13099 if err != nil { 13100 return err 13101 } 13102 if val == nil { 13103 break 13104 } 13105 { 13106 xtv := string(val) 13107 mv = xtv 13108 } 13109 sv = append(sv, mv) 13110 } 13111 *v = sv 13112 return nil 13113} 13114func awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(v **types.CloudWatchAlarmConfiguration, decoder smithyxml.NodeDecoder) error { 13115 if v == nil { 13116 return fmt.Errorf("unexpected nil of type %T", v) 13117 } 13118 var sv *types.CloudWatchAlarmConfiguration 13119 if *v == nil { 13120 sv = &types.CloudWatchAlarmConfiguration{} 13121 } else { 13122 sv = *v 13123 } 13124 13125 for { 13126 t, done, err := decoder.Token() 13127 if err != nil { 13128 return err 13129 } 13130 if done { 13131 break 13132 } 13133 originalDecoder := decoder 13134 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13135 switch { 13136 case strings.EqualFold("ComparisonOperator", t.Name.Local): 13137 val, err := decoder.Value() 13138 if err != nil { 13139 return err 13140 } 13141 if val == nil { 13142 break 13143 } 13144 { 13145 xtv := string(val) 13146 sv.ComparisonOperator = types.ComparisonOperator(xtv) 13147 } 13148 13149 case strings.EqualFold("Dimensions", t.Name.Local): 13150 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13151 if err := awsRestxml_deserializeDocumentDimensionList(&sv.Dimensions, nodeDecoder); err != nil { 13152 return err 13153 } 13154 13155 case strings.EqualFold("EvaluationPeriods", t.Name.Local): 13156 val, err := decoder.Value() 13157 if err != nil { 13158 return err 13159 } 13160 if val == nil { 13161 break 13162 } 13163 { 13164 xtv := string(val) 13165 i64, err := strconv.ParseInt(xtv, 10, 64) 13166 if err != nil { 13167 return err 13168 } 13169 sv.EvaluationPeriods = ptr.Int32(int32(i64)) 13170 } 13171 13172 case strings.EqualFold("MetricName", t.Name.Local): 13173 val, err := decoder.Value() 13174 if err != nil { 13175 return err 13176 } 13177 if val == nil { 13178 break 13179 } 13180 { 13181 xtv := string(val) 13182 sv.MetricName = ptr.String(xtv) 13183 } 13184 13185 case strings.EqualFold("Namespace", t.Name.Local): 13186 val, err := decoder.Value() 13187 if err != nil { 13188 return err 13189 } 13190 if val == nil { 13191 break 13192 } 13193 { 13194 xtv := string(val) 13195 sv.Namespace = ptr.String(xtv) 13196 } 13197 13198 case strings.EqualFold("Period", t.Name.Local): 13199 val, err := decoder.Value() 13200 if err != nil { 13201 return err 13202 } 13203 if val == nil { 13204 break 13205 } 13206 { 13207 xtv := string(val) 13208 i64, err := strconv.ParseInt(xtv, 10, 64) 13209 if err != nil { 13210 return err 13211 } 13212 sv.Period = ptr.Int32(int32(i64)) 13213 } 13214 13215 case strings.EqualFold("Statistic", t.Name.Local): 13216 val, err := decoder.Value() 13217 if err != nil { 13218 return err 13219 } 13220 if val == nil { 13221 break 13222 } 13223 { 13224 xtv := string(val) 13225 sv.Statistic = types.Statistic(xtv) 13226 } 13227 13228 case strings.EqualFold("Threshold", t.Name.Local): 13229 val, err := decoder.Value() 13230 if err != nil { 13231 return err 13232 } 13233 if val == nil { 13234 break 13235 } 13236 { 13237 xtv := string(val) 13238 f64, err := strconv.ParseFloat(xtv, 64) 13239 if err != nil { 13240 return err 13241 } 13242 sv.Threshold = ptr.Float64(f64) 13243 } 13244 13245 default: 13246 // Do nothing and ignore the unexpected tag element 13247 err = decoder.Decoder.Skip() 13248 if err != nil { 13249 return err 13250 } 13251 13252 } 13253 decoder = originalDecoder 13254 } 13255 *v = sv 13256 return nil 13257} 13258 13259func awsRestxml_deserializeDocumentConcurrentModification(v **types.ConcurrentModification, decoder smithyxml.NodeDecoder) error { 13260 if v == nil { 13261 return fmt.Errorf("unexpected nil of type %T", v) 13262 } 13263 var sv *types.ConcurrentModification 13264 if *v == nil { 13265 sv = &types.ConcurrentModification{} 13266 } else { 13267 sv = *v 13268 } 13269 13270 for { 13271 t, done, err := decoder.Token() 13272 if err != nil { 13273 return err 13274 } 13275 if done { 13276 break 13277 } 13278 originalDecoder := decoder 13279 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13280 switch { 13281 case strings.EqualFold("message", t.Name.Local): 13282 val, err := decoder.Value() 13283 if err != nil { 13284 return err 13285 } 13286 if val == nil { 13287 break 13288 } 13289 { 13290 xtv := string(val) 13291 sv.Message = ptr.String(xtv) 13292 } 13293 13294 default: 13295 // Do nothing and ignore the unexpected tag element 13296 err = decoder.Decoder.Skip() 13297 if err != nil { 13298 return err 13299 } 13300 13301 } 13302 decoder = originalDecoder 13303 } 13304 *v = sv 13305 return nil 13306} 13307 13308func awsRestxml_deserializeDocumentConflictingDomainExists(v **types.ConflictingDomainExists, decoder smithyxml.NodeDecoder) error { 13309 if v == nil { 13310 return fmt.Errorf("unexpected nil of type %T", v) 13311 } 13312 var sv *types.ConflictingDomainExists 13313 if *v == nil { 13314 sv = &types.ConflictingDomainExists{} 13315 } else { 13316 sv = *v 13317 } 13318 13319 for { 13320 t, done, err := decoder.Token() 13321 if err != nil { 13322 return err 13323 } 13324 if done { 13325 break 13326 } 13327 originalDecoder := decoder 13328 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13329 switch { 13330 case strings.EqualFold("message", t.Name.Local): 13331 val, err := decoder.Value() 13332 if err != nil { 13333 return err 13334 } 13335 if val == nil { 13336 break 13337 } 13338 { 13339 xtv := string(val) 13340 sv.Message = ptr.String(xtv) 13341 } 13342 13343 default: 13344 // Do nothing and ignore the unexpected tag element 13345 err = decoder.Decoder.Skip() 13346 if err != nil { 13347 return err 13348 } 13349 13350 } 13351 decoder = originalDecoder 13352 } 13353 *v = sv 13354 return nil 13355} 13356 13357func awsRestxml_deserializeDocumentConflictingTypes(v **types.ConflictingTypes, decoder smithyxml.NodeDecoder) error { 13358 if v == nil { 13359 return fmt.Errorf("unexpected nil of type %T", v) 13360 } 13361 var sv *types.ConflictingTypes 13362 if *v == nil { 13363 sv = &types.ConflictingTypes{} 13364 } else { 13365 sv = *v 13366 } 13367 13368 for { 13369 t, done, err := decoder.Token() 13370 if err != nil { 13371 return err 13372 } 13373 if done { 13374 break 13375 } 13376 originalDecoder := decoder 13377 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13378 switch { 13379 case strings.EqualFold("message", t.Name.Local): 13380 val, err := decoder.Value() 13381 if err != nil { 13382 return err 13383 } 13384 if val == nil { 13385 break 13386 } 13387 { 13388 xtv := string(val) 13389 sv.Message = ptr.String(xtv) 13390 } 13391 13392 default: 13393 // Do nothing and ignore the unexpected tag element 13394 err = decoder.Decoder.Skip() 13395 if err != nil { 13396 return err 13397 } 13398 13399 } 13400 decoder = originalDecoder 13401 } 13402 *v = sv 13403 return nil 13404} 13405 13406func awsRestxml_deserializeDocumentDelegationSet(v **types.DelegationSet, decoder smithyxml.NodeDecoder) error { 13407 if v == nil { 13408 return fmt.Errorf("unexpected nil of type %T", v) 13409 } 13410 var sv *types.DelegationSet 13411 if *v == nil { 13412 sv = &types.DelegationSet{} 13413 } else { 13414 sv = *v 13415 } 13416 13417 for { 13418 t, done, err := decoder.Token() 13419 if err != nil { 13420 return err 13421 } 13422 if done { 13423 break 13424 } 13425 originalDecoder := decoder 13426 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13427 switch { 13428 case strings.EqualFold("CallerReference", t.Name.Local): 13429 val, err := decoder.Value() 13430 if err != nil { 13431 return err 13432 } 13433 if val == nil { 13434 break 13435 } 13436 { 13437 xtv := string(val) 13438 sv.CallerReference = ptr.String(xtv) 13439 } 13440 13441 case strings.EqualFold("Id", t.Name.Local): 13442 val, err := decoder.Value() 13443 if err != nil { 13444 return err 13445 } 13446 if val == nil { 13447 break 13448 } 13449 { 13450 xtv := string(val) 13451 sv.Id = ptr.String(xtv) 13452 } 13453 13454 case strings.EqualFold("NameServers", t.Name.Local): 13455 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13456 if err := awsRestxml_deserializeDocumentDelegationSetNameServers(&sv.NameServers, nodeDecoder); err != nil { 13457 return err 13458 } 13459 13460 default: 13461 // Do nothing and ignore the unexpected tag element 13462 err = decoder.Decoder.Skip() 13463 if err != nil { 13464 return err 13465 } 13466 13467 } 13468 decoder = originalDecoder 13469 } 13470 *v = sv 13471 return nil 13472} 13473 13474func awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(v **types.DelegationSetAlreadyCreated, decoder smithyxml.NodeDecoder) error { 13475 if v == nil { 13476 return fmt.Errorf("unexpected nil of type %T", v) 13477 } 13478 var sv *types.DelegationSetAlreadyCreated 13479 if *v == nil { 13480 sv = &types.DelegationSetAlreadyCreated{} 13481 } else { 13482 sv = *v 13483 } 13484 13485 for { 13486 t, done, err := decoder.Token() 13487 if err != nil { 13488 return err 13489 } 13490 if done { 13491 break 13492 } 13493 originalDecoder := decoder 13494 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13495 switch { 13496 case strings.EqualFold("message", t.Name.Local): 13497 val, err := decoder.Value() 13498 if err != nil { 13499 return err 13500 } 13501 if val == nil { 13502 break 13503 } 13504 { 13505 xtv := string(val) 13506 sv.Message = ptr.String(xtv) 13507 } 13508 13509 default: 13510 // Do nothing and ignore the unexpected tag element 13511 err = decoder.Decoder.Skip() 13512 if err != nil { 13513 return err 13514 } 13515 13516 } 13517 decoder = originalDecoder 13518 } 13519 *v = sv 13520 return nil 13521} 13522 13523func awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(v **types.DelegationSetAlreadyReusable, decoder smithyxml.NodeDecoder) error { 13524 if v == nil { 13525 return fmt.Errorf("unexpected nil of type %T", v) 13526 } 13527 var sv *types.DelegationSetAlreadyReusable 13528 if *v == nil { 13529 sv = &types.DelegationSetAlreadyReusable{} 13530 } else { 13531 sv = *v 13532 } 13533 13534 for { 13535 t, done, err := decoder.Token() 13536 if err != nil { 13537 return err 13538 } 13539 if done { 13540 break 13541 } 13542 originalDecoder := decoder 13543 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13544 switch { 13545 case strings.EqualFold("message", t.Name.Local): 13546 val, err := decoder.Value() 13547 if err != nil { 13548 return err 13549 } 13550 if val == nil { 13551 break 13552 } 13553 { 13554 xtv := string(val) 13555 sv.Message = ptr.String(xtv) 13556 } 13557 13558 default: 13559 // Do nothing and ignore the unexpected tag element 13560 err = decoder.Decoder.Skip() 13561 if err != nil { 13562 return err 13563 } 13564 13565 } 13566 decoder = originalDecoder 13567 } 13568 *v = sv 13569 return nil 13570} 13571 13572func awsRestxml_deserializeDocumentDelegationSetInUse(v **types.DelegationSetInUse, decoder smithyxml.NodeDecoder) error { 13573 if v == nil { 13574 return fmt.Errorf("unexpected nil of type %T", v) 13575 } 13576 var sv *types.DelegationSetInUse 13577 if *v == nil { 13578 sv = &types.DelegationSetInUse{} 13579 } else { 13580 sv = *v 13581 } 13582 13583 for { 13584 t, done, err := decoder.Token() 13585 if err != nil { 13586 return err 13587 } 13588 if done { 13589 break 13590 } 13591 originalDecoder := decoder 13592 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13593 switch { 13594 case strings.EqualFold("message", t.Name.Local): 13595 val, err := decoder.Value() 13596 if err != nil { 13597 return err 13598 } 13599 if val == nil { 13600 break 13601 } 13602 { 13603 xtv := string(val) 13604 sv.Message = ptr.String(xtv) 13605 } 13606 13607 default: 13608 // Do nothing and ignore the unexpected tag element 13609 err = decoder.Decoder.Skip() 13610 if err != nil { 13611 return err 13612 } 13613 13614 } 13615 decoder = originalDecoder 13616 } 13617 *v = sv 13618 return nil 13619} 13620 13621func awsRestxml_deserializeDocumentDelegationSetNameServers(v *[]string, decoder smithyxml.NodeDecoder) error { 13622 if v == nil { 13623 return fmt.Errorf("unexpected nil of type %T", v) 13624 } 13625 var sv []string 13626 if *v == nil { 13627 sv = make([]string, 0) 13628 } else { 13629 sv = *v 13630 } 13631 13632 originalDecoder := decoder 13633 for { 13634 t, done, err := decoder.Token() 13635 if err != nil { 13636 return err 13637 } 13638 if done { 13639 break 13640 } 13641 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13642 decoder = memberDecoder 13643 switch { 13644 case strings.EqualFold("NameServer", t.Name.Local): 13645 var col string 13646 val, err := decoder.Value() 13647 if err != nil { 13648 return err 13649 } 13650 if val == nil { 13651 break 13652 } 13653 { 13654 xtv := string(val) 13655 col = xtv 13656 } 13657 sv = append(sv, col) 13658 13659 default: 13660 err = decoder.Decoder.Skip() 13661 if err != nil { 13662 return err 13663 } 13664 13665 } 13666 decoder = originalDecoder 13667 } 13668 *v = sv 13669 return nil 13670} 13671 13672func awsRestxml_deserializeDocumentDelegationSetNameServersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13673 var sv []string 13674 if *v == nil { 13675 sv = make([]string, 0) 13676 } else { 13677 sv = *v 13678 } 13679 13680 switch { 13681 default: 13682 var mv string 13683 t := decoder.StartEl 13684 _ = t 13685 val, err := decoder.Value() 13686 if err != nil { 13687 return err 13688 } 13689 if val == nil { 13690 break 13691 } 13692 { 13693 xtv := string(val) 13694 mv = xtv 13695 } 13696 sv = append(sv, mv) 13697 } 13698 *v = sv 13699 return nil 13700} 13701func awsRestxml_deserializeDocumentDelegationSetNotAvailable(v **types.DelegationSetNotAvailable, decoder smithyxml.NodeDecoder) error { 13702 if v == nil { 13703 return fmt.Errorf("unexpected nil of type %T", v) 13704 } 13705 var sv *types.DelegationSetNotAvailable 13706 if *v == nil { 13707 sv = &types.DelegationSetNotAvailable{} 13708 } else { 13709 sv = *v 13710 } 13711 13712 for { 13713 t, done, err := decoder.Token() 13714 if err != nil { 13715 return err 13716 } 13717 if done { 13718 break 13719 } 13720 originalDecoder := decoder 13721 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13722 switch { 13723 case strings.EqualFold("message", t.Name.Local): 13724 val, err := decoder.Value() 13725 if err != nil { 13726 return err 13727 } 13728 if val == nil { 13729 break 13730 } 13731 { 13732 xtv := string(val) 13733 sv.Message = ptr.String(xtv) 13734 } 13735 13736 default: 13737 // Do nothing and ignore the unexpected tag element 13738 err = decoder.Decoder.Skip() 13739 if err != nil { 13740 return err 13741 } 13742 13743 } 13744 decoder = originalDecoder 13745 } 13746 *v = sv 13747 return nil 13748} 13749 13750func awsRestxml_deserializeDocumentDelegationSetNotReusable(v **types.DelegationSetNotReusable, decoder smithyxml.NodeDecoder) error { 13751 if v == nil { 13752 return fmt.Errorf("unexpected nil of type %T", v) 13753 } 13754 var sv *types.DelegationSetNotReusable 13755 if *v == nil { 13756 sv = &types.DelegationSetNotReusable{} 13757 } else { 13758 sv = *v 13759 } 13760 13761 for { 13762 t, done, err := decoder.Token() 13763 if err != nil { 13764 return err 13765 } 13766 if done { 13767 break 13768 } 13769 originalDecoder := decoder 13770 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13771 switch { 13772 case strings.EqualFold("message", t.Name.Local): 13773 val, err := decoder.Value() 13774 if err != nil { 13775 return err 13776 } 13777 if val == nil { 13778 break 13779 } 13780 { 13781 xtv := string(val) 13782 sv.Message = ptr.String(xtv) 13783 } 13784 13785 default: 13786 // Do nothing and ignore the unexpected tag element 13787 err = decoder.Decoder.Skip() 13788 if err != nil { 13789 return err 13790 } 13791 13792 } 13793 decoder = originalDecoder 13794 } 13795 *v = sv 13796 return nil 13797} 13798 13799func awsRestxml_deserializeDocumentDelegationSets(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error { 13800 if v == nil { 13801 return fmt.Errorf("unexpected nil of type %T", v) 13802 } 13803 var sv []types.DelegationSet 13804 if *v == nil { 13805 sv = make([]types.DelegationSet, 0) 13806 } else { 13807 sv = *v 13808 } 13809 13810 originalDecoder := decoder 13811 for { 13812 t, done, err := decoder.Token() 13813 if err != nil { 13814 return err 13815 } 13816 if done { 13817 break 13818 } 13819 switch { 13820 case strings.EqualFold("DelegationSet", t.Name.Local): 13821 var col types.DelegationSet 13822 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13823 destAddr := &col 13824 if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil { 13825 return err 13826 } 13827 col = *destAddr 13828 sv = append(sv, col) 13829 13830 default: 13831 err = decoder.Decoder.Skip() 13832 if err != nil { 13833 return err 13834 } 13835 13836 } 13837 decoder = originalDecoder 13838 } 13839 *v = sv 13840 return nil 13841} 13842 13843func awsRestxml_deserializeDocumentDelegationSetsUnwrapped(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error { 13844 var sv []types.DelegationSet 13845 if *v == nil { 13846 sv = make([]types.DelegationSet, 0) 13847 } else { 13848 sv = *v 13849 } 13850 13851 switch { 13852 default: 13853 var mv types.DelegationSet 13854 t := decoder.StartEl 13855 _ = t 13856 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13857 destAddr := &mv 13858 if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil { 13859 return err 13860 } 13861 mv = *destAddr 13862 sv = append(sv, mv) 13863 } 13864 *v = sv 13865 return nil 13866} 13867func awsRestxml_deserializeDocumentDimension(v **types.Dimension, decoder smithyxml.NodeDecoder) error { 13868 if v == nil { 13869 return fmt.Errorf("unexpected nil of type %T", v) 13870 } 13871 var sv *types.Dimension 13872 if *v == nil { 13873 sv = &types.Dimension{} 13874 } else { 13875 sv = *v 13876 } 13877 13878 for { 13879 t, done, err := decoder.Token() 13880 if err != nil { 13881 return err 13882 } 13883 if done { 13884 break 13885 } 13886 originalDecoder := decoder 13887 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13888 switch { 13889 case strings.EqualFold("Name", t.Name.Local): 13890 val, err := decoder.Value() 13891 if err != nil { 13892 return err 13893 } 13894 if val == nil { 13895 break 13896 } 13897 { 13898 xtv := string(val) 13899 sv.Name = ptr.String(xtv) 13900 } 13901 13902 case strings.EqualFold("Value", t.Name.Local): 13903 val, err := decoder.Value() 13904 if err != nil { 13905 return err 13906 } 13907 if val == nil { 13908 break 13909 } 13910 { 13911 xtv := string(val) 13912 sv.Value = ptr.String(xtv) 13913 } 13914 13915 default: 13916 // Do nothing and ignore the unexpected tag element 13917 err = decoder.Decoder.Skip() 13918 if err != nil { 13919 return err 13920 } 13921 13922 } 13923 decoder = originalDecoder 13924 } 13925 *v = sv 13926 return nil 13927} 13928 13929func awsRestxml_deserializeDocumentDimensionList(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error { 13930 if v == nil { 13931 return fmt.Errorf("unexpected nil of type %T", v) 13932 } 13933 var sv []types.Dimension 13934 if *v == nil { 13935 sv = make([]types.Dimension, 0) 13936 } else { 13937 sv = *v 13938 } 13939 13940 originalDecoder := decoder 13941 for { 13942 t, done, err := decoder.Token() 13943 if err != nil { 13944 return err 13945 } 13946 if done { 13947 break 13948 } 13949 switch { 13950 case strings.EqualFold("Dimension", t.Name.Local): 13951 var col types.Dimension 13952 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13953 destAddr := &col 13954 if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil { 13955 return err 13956 } 13957 col = *destAddr 13958 sv = append(sv, col) 13959 13960 default: 13961 err = decoder.Decoder.Skip() 13962 if err != nil { 13963 return err 13964 } 13965 13966 } 13967 decoder = originalDecoder 13968 } 13969 *v = sv 13970 return nil 13971} 13972 13973func awsRestxml_deserializeDocumentDimensionListUnwrapped(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error { 13974 var sv []types.Dimension 13975 if *v == nil { 13976 sv = make([]types.Dimension, 0) 13977 } else { 13978 sv = *v 13979 } 13980 13981 switch { 13982 default: 13983 var mv types.Dimension 13984 t := decoder.StartEl 13985 _ = t 13986 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13987 destAddr := &mv 13988 if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil { 13989 return err 13990 } 13991 mv = *destAddr 13992 sv = append(sv, mv) 13993 } 13994 *v = sv 13995 return nil 13996} 13997func awsRestxml_deserializeDocumentDNSSECNotFound(v **types.DNSSECNotFound, decoder smithyxml.NodeDecoder) error { 13998 if v == nil { 13999 return fmt.Errorf("unexpected nil of type %T", v) 14000 } 14001 var sv *types.DNSSECNotFound 14002 if *v == nil { 14003 sv = &types.DNSSECNotFound{} 14004 } else { 14005 sv = *v 14006 } 14007 14008 for { 14009 t, done, err := decoder.Token() 14010 if err != nil { 14011 return err 14012 } 14013 if done { 14014 break 14015 } 14016 originalDecoder := decoder 14017 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14018 switch { 14019 case strings.EqualFold("message", t.Name.Local): 14020 val, err := decoder.Value() 14021 if err != nil { 14022 return err 14023 } 14024 if val == nil { 14025 break 14026 } 14027 { 14028 xtv := string(val) 14029 sv.Message = ptr.String(xtv) 14030 } 14031 14032 default: 14033 // Do nothing and ignore the unexpected tag element 14034 err = decoder.Decoder.Skip() 14035 if err != nil { 14036 return err 14037 } 14038 14039 } 14040 decoder = originalDecoder 14041 } 14042 *v = sv 14043 return nil 14044} 14045 14046func awsRestxml_deserializeDocumentDNSSECStatus(v **types.DNSSECStatus, decoder smithyxml.NodeDecoder) error { 14047 if v == nil { 14048 return fmt.Errorf("unexpected nil of type %T", v) 14049 } 14050 var sv *types.DNSSECStatus 14051 if *v == nil { 14052 sv = &types.DNSSECStatus{} 14053 } else { 14054 sv = *v 14055 } 14056 14057 for { 14058 t, done, err := decoder.Token() 14059 if err != nil { 14060 return err 14061 } 14062 if done { 14063 break 14064 } 14065 originalDecoder := decoder 14066 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14067 switch { 14068 case strings.EqualFold("ServeSignature", t.Name.Local): 14069 val, err := decoder.Value() 14070 if err != nil { 14071 return err 14072 } 14073 if val == nil { 14074 break 14075 } 14076 { 14077 xtv := string(val) 14078 sv.ServeSignature = ptr.String(xtv) 14079 } 14080 14081 case strings.EqualFold("StatusMessage", t.Name.Local): 14082 val, err := decoder.Value() 14083 if err != nil { 14084 return err 14085 } 14086 if val == nil { 14087 break 14088 } 14089 { 14090 xtv := string(val) 14091 sv.StatusMessage = ptr.String(xtv) 14092 } 14093 14094 default: 14095 // Do nothing and ignore the unexpected tag element 14096 err = decoder.Decoder.Skip() 14097 if err != nil { 14098 return err 14099 } 14100 14101 } 14102 decoder = originalDecoder 14103 } 14104 *v = sv 14105 return nil 14106} 14107 14108func awsRestxml_deserializeDocumentErrorMessages(v *[]string, decoder smithyxml.NodeDecoder) error { 14109 if v == nil { 14110 return fmt.Errorf("unexpected nil of type %T", v) 14111 } 14112 var sv []string 14113 if *v == nil { 14114 sv = make([]string, 0) 14115 } else { 14116 sv = *v 14117 } 14118 14119 originalDecoder := decoder 14120 for { 14121 t, done, err := decoder.Token() 14122 if err != nil { 14123 return err 14124 } 14125 if done { 14126 break 14127 } 14128 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14129 decoder = memberDecoder 14130 switch { 14131 case strings.EqualFold("Message", t.Name.Local): 14132 var col string 14133 val, err := decoder.Value() 14134 if err != nil { 14135 return err 14136 } 14137 if val == nil { 14138 break 14139 } 14140 { 14141 xtv := string(val) 14142 col = xtv 14143 } 14144 sv = append(sv, col) 14145 14146 default: 14147 err = decoder.Decoder.Skip() 14148 if err != nil { 14149 return err 14150 } 14151 14152 } 14153 decoder = originalDecoder 14154 } 14155 *v = sv 14156 return nil 14157} 14158 14159func awsRestxml_deserializeDocumentErrorMessagesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 14160 var sv []string 14161 if *v == nil { 14162 sv = make([]string, 0) 14163 } else { 14164 sv = *v 14165 } 14166 14167 switch { 14168 default: 14169 var mv string 14170 t := decoder.StartEl 14171 _ = t 14172 val, err := decoder.Value() 14173 if err != nil { 14174 return err 14175 } 14176 if val == nil { 14177 break 14178 } 14179 { 14180 xtv := string(val) 14181 mv = xtv 14182 } 14183 sv = append(sv, mv) 14184 } 14185 *v = sv 14186 return nil 14187} 14188func awsRestxml_deserializeDocumentGeoLocation(v **types.GeoLocation, decoder smithyxml.NodeDecoder) error { 14189 if v == nil { 14190 return fmt.Errorf("unexpected nil of type %T", v) 14191 } 14192 var sv *types.GeoLocation 14193 if *v == nil { 14194 sv = &types.GeoLocation{} 14195 } else { 14196 sv = *v 14197 } 14198 14199 for { 14200 t, done, err := decoder.Token() 14201 if err != nil { 14202 return err 14203 } 14204 if done { 14205 break 14206 } 14207 originalDecoder := decoder 14208 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14209 switch { 14210 case strings.EqualFold("ContinentCode", t.Name.Local): 14211 val, err := decoder.Value() 14212 if err != nil { 14213 return err 14214 } 14215 if val == nil { 14216 break 14217 } 14218 { 14219 xtv := string(val) 14220 sv.ContinentCode = ptr.String(xtv) 14221 } 14222 14223 case strings.EqualFold("CountryCode", t.Name.Local): 14224 val, err := decoder.Value() 14225 if err != nil { 14226 return err 14227 } 14228 if val == nil { 14229 break 14230 } 14231 { 14232 xtv := string(val) 14233 sv.CountryCode = ptr.String(xtv) 14234 } 14235 14236 case strings.EqualFold("SubdivisionCode", t.Name.Local): 14237 val, err := decoder.Value() 14238 if err != nil { 14239 return err 14240 } 14241 if val == nil { 14242 break 14243 } 14244 { 14245 xtv := string(val) 14246 sv.SubdivisionCode = ptr.String(xtv) 14247 } 14248 14249 default: 14250 // Do nothing and ignore the unexpected tag element 14251 err = decoder.Decoder.Skip() 14252 if err != nil { 14253 return err 14254 } 14255 14256 } 14257 decoder = originalDecoder 14258 } 14259 *v = sv 14260 return nil 14261} 14262 14263func awsRestxml_deserializeDocumentGeoLocationDetails(v **types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error { 14264 if v == nil { 14265 return fmt.Errorf("unexpected nil of type %T", v) 14266 } 14267 var sv *types.GeoLocationDetails 14268 if *v == nil { 14269 sv = &types.GeoLocationDetails{} 14270 } else { 14271 sv = *v 14272 } 14273 14274 for { 14275 t, done, err := decoder.Token() 14276 if err != nil { 14277 return err 14278 } 14279 if done { 14280 break 14281 } 14282 originalDecoder := decoder 14283 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14284 switch { 14285 case strings.EqualFold("ContinentCode", t.Name.Local): 14286 val, err := decoder.Value() 14287 if err != nil { 14288 return err 14289 } 14290 if val == nil { 14291 break 14292 } 14293 { 14294 xtv := string(val) 14295 sv.ContinentCode = ptr.String(xtv) 14296 } 14297 14298 case strings.EqualFold("ContinentName", t.Name.Local): 14299 val, err := decoder.Value() 14300 if err != nil { 14301 return err 14302 } 14303 if val == nil { 14304 break 14305 } 14306 { 14307 xtv := string(val) 14308 sv.ContinentName = ptr.String(xtv) 14309 } 14310 14311 case strings.EqualFold("CountryCode", t.Name.Local): 14312 val, err := decoder.Value() 14313 if err != nil { 14314 return err 14315 } 14316 if val == nil { 14317 break 14318 } 14319 { 14320 xtv := string(val) 14321 sv.CountryCode = ptr.String(xtv) 14322 } 14323 14324 case strings.EqualFold("CountryName", t.Name.Local): 14325 val, err := decoder.Value() 14326 if err != nil { 14327 return err 14328 } 14329 if val == nil { 14330 break 14331 } 14332 { 14333 xtv := string(val) 14334 sv.CountryName = ptr.String(xtv) 14335 } 14336 14337 case strings.EqualFold("SubdivisionCode", t.Name.Local): 14338 val, err := decoder.Value() 14339 if err != nil { 14340 return err 14341 } 14342 if val == nil { 14343 break 14344 } 14345 { 14346 xtv := string(val) 14347 sv.SubdivisionCode = ptr.String(xtv) 14348 } 14349 14350 case strings.EqualFold("SubdivisionName", t.Name.Local): 14351 val, err := decoder.Value() 14352 if err != nil { 14353 return err 14354 } 14355 if val == nil { 14356 break 14357 } 14358 { 14359 xtv := string(val) 14360 sv.SubdivisionName = ptr.String(xtv) 14361 } 14362 14363 default: 14364 // Do nothing and ignore the unexpected tag element 14365 err = decoder.Decoder.Skip() 14366 if err != nil { 14367 return err 14368 } 14369 14370 } 14371 decoder = originalDecoder 14372 } 14373 *v = sv 14374 return nil 14375} 14376 14377func awsRestxml_deserializeDocumentGeoLocationDetailsList(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error { 14378 if v == nil { 14379 return fmt.Errorf("unexpected nil of type %T", v) 14380 } 14381 var sv []types.GeoLocationDetails 14382 if *v == nil { 14383 sv = make([]types.GeoLocationDetails, 0) 14384 } else { 14385 sv = *v 14386 } 14387 14388 originalDecoder := decoder 14389 for { 14390 t, done, err := decoder.Token() 14391 if err != nil { 14392 return err 14393 } 14394 if done { 14395 break 14396 } 14397 switch { 14398 case strings.EqualFold("GeoLocationDetails", t.Name.Local): 14399 var col types.GeoLocationDetails 14400 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14401 destAddr := &col 14402 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil { 14403 return err 14404 } 14405 col = *destAddr 14406 sv = append(sv, col) 14407 14408 default: 14409 err = decoder.Decoder.Skip() 14410 if err != nil { 14411 return err 14412 } 14413 14414 } 14415 decoder = originalDecoder 14416 } 14417 *v = sv 14418 return nil 14419} 14420 14421func awsRestxml_deserializeDocumentGeoLocationDetailsListUnwrapped(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error { 14422 var sv []types.GeoLocationDetails 14423 if *v == nil { 14424 sv = make([]types.GeoLocationDetails, 0) 14425 } else { 14426 sv = *v 14427 } 14428 14429 switch { 14430 default: 14431 var mv types.GeoLocationDetails 14432 t := decoder.StartEl 14433 _ = t 14434 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14435 destAddr := &mv 14436 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil { 14437 return err 14438 } 14439 mv = *destAddr 14440 sv = append(sv, mv) 14441 } 14442 *v = sv 14443 return nil 14444} 14445func awsRestxml_deserializeDocumentHealthCheck(v **types.HealthCheck, decoder smithyxml.NodeDecoder) error { 14446 if v == nil { 14447 return fmt.Errorf("unexpected nil of type %T", v) 14448 } 14449 var sv *types.HealthCheck 14450 if *v == nil { 14451 sv = &types.HealthCheck{} 14452 } else { 14453 sv = *v 14454 } 14455 14456 for { 14457 t, done, err := decoder.Token() 14458 if err != nil { 14459 return err 14460 } 14461 if done { 14462 break 14463 } 14464 originalDecoder := decoder 14465 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14466 switch { 14467 case strings.EqualFold("CallerReference", t.Name.Local): 14468 val, err := decoder.Value() 14469 if err != nil { 14470 return err 14471 } 14472 if val == nil { 14473 break 14474 } 14475 { 14476 xtv := string(val) 14477 sv.CallerReference = ptr.String(xtv) 14478 } 14479 14480 case strings.EqualFold("CloudWatchAlarmConfiguration", t.Name.Local): 14481 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14482 if err := awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(&sv.CloudWatchAlarmConfiguration, nodeDecoder); err != nil { 14483 return err 14484 } 14485 14486 case strings.EqualFold("HealthCheckConfig", t.Name.Local): 14487 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14488 if err := awsRestxml_deserializeDocumentHealthCheckConfig(&sv.HealthCheckConfig, nodeDecoder); err != nil { 14489 return err 14490 } 14491 14492 case strings.EqualFold("HealthCheckVersion", t.Name.Local): 14493 val, err := decoder.Value() 14494 if err != nil { 14495 return err 14496 } 14497 if val == nil { 14498 break 14499 } 14500 { 14501 xtv := string(val) 14502 i64, err := strconv.ParseInt(xtv, 10, 64) 14503 if err != nil { 14504 return err 14505 } 14506 sv.HealthCheckVersion = ptr.Int64(i64) 14507 } 14508 14509 case strings.EqualFold("Id", t.Name.Local): 14510 val, err := decoder.Value() 14511 if err != nil { 14512 return err 14513 } 14514 if val == nil { 14515 break 14516 } 14517 { 14518 xtv := string(val) 14519 sv.Id = ptr.String(xtv) 14520 } 14521 14522 case strings.EqualFold("LinkedService", t.Name.Local): 14523 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14524 if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil { 14525 return err 14526 } 14527 14528 default: 14529 // Do nothing and ignore the unexpected tag element 14530 err = decoder.Decoder.Skip() 14531 if err != nil { 14532 return err 14533 } 14534 14535 } 14536 decoder = originalDecoder 14537 } 14538 *v = sv 14539 return nil 14540} 14541 14542func awsRestxml_deserializeDocumentHealthCheckAlreadyExists(v **types.HealthCheckAlreadyExists, decoder smithyxml.NodeDecoder) error { 14543 if v == nil { 14544 return fmt.Errorf("unexpected nil of type %T", v) 14545 } 14546 var sv *types.HealthCheckAlreadyExists 14547 if *v == nil { 14548 sv = &types.HealthCheckAlreadyExists{} 14549 } else { 14550 sv = *v 14551 } 14552 14553 for { 14554 t, done, err := decoder.Token() 14555 if err != nil { 14556 return err 14557 } 14558 if done { 14559 break 14560 } 14561 originalDecoder := decoder 14562 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14563 switch { 14564 case strings.EqualFold("message", t.Name.Local): 14565 val, err := decoder.Value() 14566 if err != nil { 14567 return err 14568 } 14569 if val == nil { 14570 break 14571 } 14572 { 14573 xtv := string(val) 14574 sv.Message = ptr.String(xtv) 14575 } 14576 14577 default: 14578 // Do nothing and ignore the unexpected tag element 14579 err = decoder.Decoder.Skip() 14580 if err != nil { 14581 return err 14582 } 14583 14584 } 14585 decoder = originalDecoder 14586 } 14587 *v = sv 14588 return nil 14589} 14590 14591func awsRestxml_deserializeDocumentHealthCheckConfig(v **types.HealthCheckConfig, decoder smithyxml.NodeDecoder) error { 14592 if v == nil { 14593 return fmt.Errorf("unexpected nil of type %T", v) 14594 } 14595 var sv *types.HealthCheckConfig 14596 if *v == nil { 14597 sv = &types.HealthCheckConfig{} 14598 } else { 14599 sv = *v 14600 } 14601 14602 for { 14603 t, done, err := decoder.Token() 14604 if err != nil { 14605 return err 14606 } 14607 if done { 14608 break 14609 } 14610 originalDecoder := decoder 14611 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14612 switch { 14613 case strings.EqualFold("AlarmIdentifier", t.Name.Local): 14614 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14615 if err := awsRestxml_deserializeDocumentAlarmIdentifier(&sv.AlarmIdentifier, nodeDecoder); err != nil { 14616 return err 14617 } 14618 14619 case strings.EqualFold("ChildHealthChecks", t.Name.Local): 14620 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14621 if err := awsRestxml_deserializeDocumentChildHealthCheckList(&sv.ChildHealthChecks, nodeDecoder); err != nil { 14622 return err 14623 } 14624 14625 case strings.EqualFold("Disabled", t.Name.Local): 14626 val, err := decoder.Value() 14627 if err != nil { 14628 return err 14629 } 14630 if val == nil { 14631 break 14632 } 14633 { 14634 xtv, err := strconv.ParseBool(string(val)) 14635 if err != nil { 14636 return fmt.Errorf("expected Disabled to be of type *bool, got %T instead", val) 14637 } 14638 sv.Disabled = ptr.Bool(xtv) 14639 } 14640 14641 case strings.EqualFold("EnableSNI", t.Name.Local): 14642 val, err := decoder.Value() 14643 if err != nil { 14644 return err 14645 } 14646 if val == nil { 14647 break 14648 } 14649 { 14650 xtv, err := strconv.ParseBool(string(val)) 14651 if err != nil { 14652 return fmt.Errorf("expected EnableSNI to be of type *bool, got %T instead", val) 14653 } 14654 sv.EnableSNI = ptr.Bool(xtv) 14655 } 14656 14657 case strings.EqualFold("FailureThreshold", t.Name.Local): 14658 val, err := decoder.Value() 14659 if err != nil { 14660 return err 14661 } 14662 if val == nil { 14663 break 14664 } 14665 { 14666 xtv := string(val) 14667 i64, err := strconv.ParseInt(xtv, 10, 64) 14668 if err != nil { 14669 return err 14670 } 14671 sv.FailureThreshold = ptr.Int32(int32(i64)) 14672 } 14673 14674 case strings.EqualFold("FullyQualifiedDomainName", t.Name.Local): 14675 val, err := decoder.Value() 14676 if err != nil { 14677 return err 14678 } 14679 if val == nil { 14680 break 14681 } 14682 { 14683 xtv := string(val) 14684 sv.FullyQualifiedDomainName = ptr.String(xtv) 14685 } 14686 14687 case strings.EqualFold("HealthThreshold", t.Name.Local): 14688 val, err := decoder.Value() 14689 if err != nil { 14690 return err 14691 } 14692 if val == nil { 14693 break 14694 } 14695 { 14696 xtv := string(val) 14697 i64, err := strconv.ParseInt(xtv, 10, 64) 14698 if err != nil { 14699 return err 14700 } 14701 sv.HealthThreshold = ptr.Int32(int32(i64)) 14702 } 14703 14704 case strings.EqualFold("InsufficientDataHealthStatus", t.Name.Local): 14705 val, err := decoder.Value() 14706 if err != nil { 14707 return err 14708 } 14709 if val == nil { 14710 break 14711 } 14712 { 14713 xtv := string(val) 14714 sv.InsufficientDataHealthStatus = types.InsufficientDataHealthStatus(xtv) 14715 } 14716 14717 case strings.EqualFold("Inverted", t.Name.Local): 14718 val, err := decoder.Value() 14719 if err != nil { 14720 return err 14721 } 14722 if val == nil { 14723 break 14724 } 14725 { 14726 xtv, err := strconv.ParseBool(string(val)) 14727 if err != nil { 14728 return fmt.Errorf("expected Inverted to be of type *bool, got %T instead", val) 14729 } 14730 sv.Inverted = ptr.Bool(xtv) 14731 } 14732 14733 case strings.EqualFold("IPAddress", t.Name.Local): 14734 val, err := decoder.Value() 14735 if err != nil { 14736 return err 14737 } 14738 if val == nil { 14739 break 14740 } 14741 { 14742 xtv := string(val) 14743 sv.IPAddress = ptr.String(xtv) 14744 } 14745 14746 case strings.EqualFold("MeasureLatency", t.Name.Local): 14747 val, err := decoder.Value() 14748 if err != nil { 14749 return err 14750 } 14751 if val == nil { 14752 break 14753 } 14754 { 14755 xtv, err := strconv.ParseBool(string(val)) 14756 if err != nil { 14757 return fmt.Errorf("expected MeasureLatency to be of type *bool, got %T instead", val) 14758 } 14759 sv.MeasureLatency = ptr.Bool(xtv) 14760 } 14761 14762 case strings.EqualFold("Port", t.Name.Local): 14763 val, err := decoder.Value() 14764 if err != nil { 14765 return err 14766 } 14767 if val == nil { 14768 break 14769 } 14770 { 14771 xtv := string(val) 14772 i64, err := strconv.ParseInt(xtv, 10, 64) 14773 if err != nil { 14774 return err 14775 } 14776 sv.Port = ptr.Int32(int32(i64)) 14777 } 14778 14779 case strings.EqualFold("Regions", t.Name.Local): 14780 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14781 if err := awsRestxml_deserializeDocumentHealthCheckRegionList(&sv.Regions, nodeDecoder); err != nil { 14782 return err 14783 } 14784 14785 case strings.EqualFold("RequestInterval", t.Name.Local): 14786 val, err := decoder.Value() 14787 if err != nil { 14788 return err 14789 } 14790 if val == nil { 14791 break 14792 } 14793 { 14794 xtv := string(val) 14795 i64, err := strconv.ParseInt(xtv, 10, 64) 14796 if err != nil { 14797 return err 14798 } 14799 sv.RequestInterval = ptr.Int32(int32(i64)) 14800 } 14801 14802 case strings.EqualFold("ResourcePath", t.Name.Local): 14803 val, err := decoder.Value() 14804 if err != nil { 14805 return err 14806 } 14807 if val == nil { 14808 break 14809 } 14810 { 14811 xtv := string(val) 14812 sv.ResourcePath = ptr.String(xtv) 14813 } 14814 14815 case strings.EqualFold("SearchString", t.Name.Local): 14816 val, err := decoder.Value() 14817 if err != nil { 14818 return err 14819 } 14820 if val == nil { 14821 break 14822 } 14823 { 14824 xtv := string(val) 14825 sv.SearchString = ptr.String(xtv) 14826 } 14827 14828 case strings.EqualFold("Type", t.Name.Local): 14829 val, err := decoder.Value() 14830 if err != nil { 14831 return err 14832 } 14833 if val == nil { 14834 break 14835 } 14836 { 14837 xtv := string(val) 14838 sv.Type = types.HealthCheckType(xtv) 14839 } 14840 14841 default: 14842 // Do nothing and ignore the unexpected tag element 14843 err = decoder.Decoder.Skip() 14844 if err != nil { 14845 return err 14846 } 14847 14848 } 14849 decoder = originalDecoder 14850 } 14851 *v = sv 14852 return nil 14853} 14854 14855func awsRestxml_deserializeDocumentHealthCheckInUse(v **types.HealthCheckInUse, decoder smithyxml.NodeDecoder) error { 14856 if v == nil { 14857 return fmt.Errorf("unexpected nil of type %T", v) 14858 } 14859 var sv *types.HealthCheckInUse 14860 if *v == nil { 14861 sv = &types.HealthCheckInUse{} 14862 } else { 14863 sv = *v 14864 } 14865 14866 for { 14867 t, done, err := decoder.Token() 14868 if err != nil { 14869 return err 14870 } 14871 if done { 14872 break 14873 } 14874 originalDecoder := decoder 14875 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14876 switch { 14877 case strings.EqualFold("message", t.Name.Local): 14878 val, err := decoder.Value() 14879 if err != nil { 14880 return err 14881 } 14882 if val == nil { 14883 break 14884 } 14885 { 14886 xtv := string(val) 14887 sv.Message = ptr.String(xtv) 14888 } 14889 14890 default: 14891 // Do nothing and ignore the unexpected tag element 14892 err = decoder.Decoder.Skip() 14893 if err != nil { 14894 return err 14895 } 14896 14897 } 14898 decoder = originalDecoder 14899 } 14900 *v = sv 14901 return nil 14902} 14903 14904func awsRestxml_deserializeDocumentHealthCheckObservation(v **types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error { 14905 if v == nil { 14906 return fmt.Errorf("unexpected nil of type %T", v) 14907 } 14908 var sv *types.HealthCheckObservation 14909 if *v == nil { 14910 sv = &types.HealthCheckObservation{} 14911 } else { 14912 sv = *v 14913 } 14914 14915 for { 14916 t, done, err := decoder.Token() 14917 if err != nil { 14918 return err 14919 } 14920 if done { 14921 break 14922 } 14923 originalDecoder := decoder 14924 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14925 switch { 14926 case strings.EqualFold("IPAddress", t.Name.Local): 14927 val, err := decoder.Value() 14928 if err != nil { 14929 return err 14930 } 14931 if val == nil { 14932 break 14933 } 14934 { 14935 xtv := string(val) 14936 sv.IPAddress = ptr.String(xtv) 14937 } 14938 14939 case strings.EqualFold("Region", t.Name.Local): 14940 val, err := decoder.Value() 14941 if err != nil { 14942 return err 14943 } 14944 if val == nil { 14945 break 14946 } 14947 { 14948 xtv := string(val) 14949 sv.Region = types.HealthCheckRegion(xtv) 14950 } 14951 14952 case strings.EqualFold("StatusReport", t.Name.Local): 14953 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14954 if err := awsRestxml_deserializeDocumentStatusReport(&sv.StatusReport, nodeDecoder); err != nil { 14955 return err 14956 } 14957 14958 default: 14959 // Do nothing and ignore the unexpected tag element 14960 err = decoder.Decoder.Skip() 14961 if err != nil { 14962 return err 14963 } 14964 14965 } 14966 decoder = originalDecoder 14967 } 14968 *v = sv 14969 return nil 14970} 14971 14972func awsRestxml_deserializeDocumentHealthCheckObservations(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error { 14973 if v == nil { 14974 return fmt.Errorf("unexpected nil of type %T", v) 14975 } 14976 var sv []types.HealthCheckObservation 14977 if *v == nil { 14978 sv = make([]types.HealthCheckObservation, 0) 14979 } else { 14980 sv = *v 14981 } 14982 14983 originalDecoder := decoder 14984 for { 14985 t, done, err := decoder.Token() 14986 if err != nil { 14987 return err 14988 } 14989 if done { 14990 break 14991 } 14992 switch { 14993 case strings.EqualFold("HealthCheckObservation", t.Name.Local): 14994 var col types.HealthCheckObservation 14995 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14996 destAddr := &col 14997 if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil { 14998 return err 14999 } 15000 col = *destAddr 15001 sv = append(sv, col) 15002 15003 default: 15004 err = decoder.Decoder.Skip() 15005 if err != nil { 15006 return err 15007 } 15008 15009 } 15010 decoder = originalDecoder 15011 } 15012 *v = sv 15013 return nil 15014} 15015 15016func awsRestxml_deserializeDocumentHealthCheckObservationsUnwrapped(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error { 15017 var sv []types.HealthCheckObservation 15018 if *v == nil { 15019 sv = make([]types.HealthCheckObservation, 0) 15020 } else { 15021 sv = *v 15022 } 15023 15024 switch { 15025 default: 15026 var mv types.HealthCheckObservation 15027 t := decoder.StartEl 15028 _ = t 15029 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15030 destAddr := &mv 15031 if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil { 15032 return err 15033 } 15034 mv = *destAddr 15035 sv = append(sv, mv) 15036 } 15037 *v = sv 15038 return nil 15039} 15040func awsRestxml_deserializeDocumentHealthCheckRegionList(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error { 15041 if v == nil { 15042 return fmt.Errorf("unexpected nil of type %T", v) 15043 } 15044 var sv []types.HealthCheckRegion 15045 if *v == nil { 15046 sv = make([]types.HealthCheckRegion, 0) 15047 } else { 15048 sv = *v 15049 } 15050 15051 originalDecoder := decoder 15052 for { 15053 t, done, err := decoder.Token() 15054 if err != nil { 15055 return err 15056 } 15057 if done { 15058 break 15059 } 15060 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15061 decoder = memberDecoder 15062 switch { 15063 case strings.EqualFold("Region", t.Name.Local): 15064 var col types.HealthCheckRegion 15065 val, err := decoder.Value() 15066 if err != nil { 15067 return err 15068 } 15069 if val == nil { 15070 break 15071 } 15072 { 15073 xtv := string(val) 15074 col = types.HealthCheckRegion(xtv) 15075 } 15076 sv = append(sv, col) 15077 15078 default: 15079 err = decoder.Decoder.Skip() 15080 if err != nil { 15081 return err 15082 } 15083 15084 } 15085 decoder = originalDecoder 15086 } 15087 *v = sv 15088 return nil 15089} 15090 15091func awsRestxml_deserializeDocumentHealthCheckRegionListUnwrapped(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error { 15092 var sv []types.HealthCheckRegion 15093 if *v == nil { 15094 sv = make([]types.HealthCheckRegion, 0) 15095 } else { 15096 sv = *v 15097 } 15098 15099 switch { 15100 default: 15101 var mv types.HealthCheckRegion 15102 t := decoder.StartEl 15103 _ = t 15104 val, err := decoder.Value() 15105 if err != nil { 15106 return err 15107 } 15108 if val == nil { 15109 break 15110 } 15111 { 15112 xtv := string(val) 15113 mv = types.HealthCheckRegion(xtv) 15114 } 15115 sv = append(sv, mv) 15116 } 15117 *v = sv 15118 return nil 15119} 15120func awsRestxml_deserializeDocumentHealthChecks(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error { 15121 if v == nil { 15122 return fmt.Errorf("unexpected nil of type %T", v) 15123 } 15124 var sv []types.HealthCheck 15125 if *v == nil { 15126 sv = make([]types.HealthCheck, 0) 15127 } else { 15128 sv = *v 15129 } 15130 15131 originalDecoder := decoder 15132 for { 15133 t, done, err := decoder.Token() 15134 if err != nil { 15135 return err 15136 } 15137 if done { 15138 break 15139 } 15140 switch { 15141 case strings.EqualFold("HealthCheck", t.Name.Local): 15142 var col types.HealthCheck 15143 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15144 destAddr := &col 15145 if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil { 15146 return err 15147 } 15148 col = *destAddr 15149 sv = append(sv, col) 15150 15151 default: 15152 err = decoder.Decoder.Skip() 15153 if err != nil { 15154 return err 15155 } 15156 15157 } 15158 decoder = originalDecoder 15159 } 15160 *v = sv 15161 return nil 15162} 15163 15164func awsRestxml_deserializeDocumentHealthChecksUnwrapped(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error { 15165 var sv []types.HealthCheck 15166 if *v == nil { 15167 sv = make([]types.HealthCheck, 0) 15168 } else { 15169 sv = *v 15170 } 15171 15172 switch { 15173 default: 15174 var mv types.HealthCheck 15175 t := decoder.StartEl 15176 _ = t 15177 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15178 destAddr := &mv 15179 if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil { 15180 return err 15181 } 15182 mv = *destAddr 15183 sv = append(sv, mv) 15184 } 15185 *v = sv 15186 return nil 15187} 15188func awsRestxml_deserializeDocumentHealthCheckVersionMismatch(v **types.HealthCheckVersionMismatch, decoder smithyxml.NodeDecoder) error { 15189 if v == nil { 15190 return fmt.Errorf("unexpected nil of type %T", v) 15191 } 15192 var sv *types.HealthCheckVersionMismatch 15193 if *v == nil { 15194 sv = &types.HealthCheckVersionMismatch{} 15195 } else { 15196 sv = *v 15197 } 15198 15199 for { 15200 t, done, err := decoder.Token() 15201 if err != nil { 15202 return err 15203 } 15204 if done { 15205 break 15206 } 15207 originalDecoder := decoder 15208 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15209 switch { 15210 case strings.EqualFold("message", t.Name.Local): 15211 val, err := decoder.Value() 15212 if err != nil { 15213 return err 15214 } 15215 if val == nil { 15216 break 15217 } 15218 { 15219 xtv := string(val) 15220 sv.Message = ptr.String(xtv) 15221 } 15222 15223 default: 15224 // Do nothing and ignore the unexpected tag element 15225 err = decoder.Decoder.Skip() 15226 if err != nil { 15227 return err 15228 } 15229 15230 } 15231 decoder = originalDecoder 15232 } 15233 *v = sv 15234 return nil 15235} 15236 15237func awsRestxml_deserializeDocumentHostedZone(v **types.HostedZone, decoder smithyxml.NodeDecoder) error { 15238 if v == nil { 15239 return fmt.Errorf("unexpected nil of type %T", v) 15240 } 15241 var sv *types.HostedZone 15242 if *v == nil { 15243 sv = &types.HostedZone{} 15244 } else { 15245 sv = *v 15246 } 15247 15248 for { 15249 t, done, err := decoder.Token() 15250 if err != nil { 15251 return err 15252 } 15253 if done { 15254 break 15255 } 15256 originalDecoder := decoder 15257 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15258 switch { 15259 case strings.EqualFold("CallerReference", t.Name.Local): 15260 val, err := decoder.Value() 15261 if err != nil { 15262 return err 15263 } 15264 if val == nil { 15265 break 15266 } 15267 { 15268 xtv := string(val) 15269 sv.CallerReference = ptr.String(xtv) 15270 } 15271 15272 case strings.EqualFold("Config", t.Name.Local): 15273 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15274 if err := awsRestxml_deserializeDocumentHostedZoneConfig(&sv.Config, nodeDecoder); err != nil { 15275 return err 15276 } 15277 15278 case strings.EqualFold("Id", t.Name.Local): 15279 val, err := decoder.Value() 15280 if err != nil { 15281 return err 15282 } 15283 if val == nil { 15284 break 15285 } 15286 { 15287 xtv := string(val) 15288 sv.Id = ptr.String(xtv) 15289 } 15290 15291 case strings.EqualFold("LinkedService", t.Name.Local): 15292 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15293 if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil { 15294 return err 15295 } 15296 15297 case strings.EqualFold("Name", t.Name.Local): 15298 val, err := decoder.Value() 15299 if err != nil { 15300 return err 15301 } 15302 if val == nil { 15303 break 15304 } 15305 { 15306 xtv := string(val) 15307 sv.Name = ptr.String(xtv) 15308 } 15309 15310 case strings.EqualFold("ResourceRecordSetCount", t.Name.Local): 15311 val, err := decoder.Value() 15312 if err != nil { 15313 return err 15314 } 15315 if val == nil { 15316 break 15317 } 15318 { 15319 xtv := string(val) 15320 i64, err := strconv.ParseInt(xtv, 10, 64) 15321 if err != nil { 15322 return err 15323 } 15324 sv.ResourceRecordSetCount = ptr.Int64(i64) 15325 } 15326 15327 default: 15328 // Do nothing and ignore the unexpected tag element 15329 err = decoder.Decoder.Skip() 15330 if err != nil { 15331 return err 15332 } 15333 15334 } 15335 decoder = originalDecoder 15336 } 15337 *v = sv 15338 return nil 15339} 15340 15341func awsRestxml_deserializeDocumentHostedZoneAlreadyExists(v **types.HostedZoneAlreadyExists, decoder smithyxml.NodeDecoder) error { 15342 if v == nil { 15343 return fmt.Errorf("unexpected nil of type %T", v) 15344 } 15345 var sv *types.HostedZoneAlreadyExists 15346 if *v == nil { 15347 sv = &types.HostedZoneAlreadyExists{} 15348 } else { 15349 sv = *v 15350 } 15351 15352 for { 15353 t, done, err := decoder.Token() 15354 if err != nil { 15355 return err 15356 } 15357 if done { 15358 break 15359 } 15360 originalDecoder := decoder 15361 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15362 switch { 15363 case strings.EqualFold("message", t.Name.Local): 15364 val, err := decoder.Value() 15365 if err != nil { 15366 return err 15367 } 15368 if val == nil { 15369 break 15370 } 15371 { 15372 xtv := string(val) 15373 sv.Message = ptr.String(xtv) 15374 } 15375 15376 default: 15377 // Do nothing and ignore the unexpected tag element 15378 err = decoder.Decoder.Skip() 15379 if err != nil { 15380 return err 15381 } 15382 15383 } 15384 decoder = originalDecoder 15385 } 15386 *v = sv 15387 return nil 15388} 15389 15390func awsRestxml_deserializeDocumentHostedZoneConfig(v **types.HostedZoneConfig, decoder smithyxml.NodeDecoder) error { 15391 if v == nil { 15392 return fmt.Errorf("unexpected nil of type %T", v) 15393 } 15394 var sv *types.HostedZoneConfig 15395 if *v == nil { 15396 sv = &types.HostedZoneConfig{} 15397 } else { 15398 sv = *v 15399 } 15400 15401 for { 15402 t, done, err := decoder.Token() 15403 if err != nil { 15404 return err 15405 } 15406 if done { 15407 break 15408 } 15409 originalDecoder := decoder 15410 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15411 switch { 15412 case strings.EqualFold("Comment", t.Name.Local): 15413 val, err := decoder.Value() 15414 if err != nil { 15415 return err 15416 } 15417 if val == nil { 15418 break 15419 } 15420 { 15421 xtv := string(val) 15422 sv.Comment = ptr.String(xtv) 15423 } 15424 15425 case strings.EqualFold("PrivateZone", t.Name.Local): 15426 val, err := decoder.Value() 15427 if err != nil { 15428 return err 15429 } 15430 if val == nil { 15431 break 15432 } 15433 { 15434 xtv, err := strconv.ParseBool(string(val)) 15435 if err != nil { 15436 return fmt.Errorf("expected IsPrivateZone to be of type *bool, got %T instead", val) 15437 } 15438 sv.PrivateZone = xtv 15439 } 15440 15441 default: 15442 // Do nothing and ignore the unexpected tag element 15443 err = decoder.Decoder.Skip() 15444 if err != nil { 15445 return err 15446 } 15447 15448 } 15449 decoder = originalDecoder 15450 } 15451 *v = sv 15452 return nil 15453} 15454 15455func awsRestxml_deserializeDocumentHostedZoneLimit(v **types.HostedZoneLimit, decoder smithyxml.NodeDecoder) error { 15456 if v == nil { 15457 return fmt.Errorf("unexpected nil of type %T", v) 15458 } 15459 var sv *types.HostedZoneLimit 15460 if *v == nil { 15461 sv = &types.HostedZoneLimit{} 15462 } else { 15463 sv = *v 15464 } 15465 15466 for { 15467 t, done, err := decoder.Token() 15468 if err != nil { 15469 return err 15470 } 15471 if done { 15472 break 15473 } 15474 originalDecoder := decoder 15475 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15476 switch { 15477 case strings.EqualFold("Type", t.Name.Local): 15478 val, err := decoder.Value() 15479 if err != nil { 15480 return err 15481 } 15482 if val == nil { 15483 break 15484 } 15485 { 15486 xtv := string(val) 15487 sv.Type = types.HostedZoneLimitType(xtv) 15488 } 15489 15490 case strings.EqualFold("Value", t.Name.Local): 15491 val, err := decoder.Value() 15492 if err != nil { 15493 return err 15494 } 15495 if val == nil { 15496 break 15497 } 15498 { 15499 xtv := string(val) 15500 i64, err := strconv.ParseInt(xtv, 10, 64) 15501 if err != nil { 15502 return err 15503 } 15504 sv.Value = i64 15505 } 15506 15507 default: 15508 // Do nothing and ignore the unexpected tag element 15509 err = decoder.Decoder.Skip() 15510 if err != nil { 15511 return err 15512 } 15513 15514 } 15515 decoder = originalDecoder 15516 } 15517 *v = sv 15518 return nil 15519} 15520 15521func awsRestxml_deserializeDocumentHostedZoneNotEmpty(v **types.HostedZoneNotEmpty, decoder smithyxml.NodeDecoder) error { 15522 if v == nil { 15523 return fmt.Errorf("unexpected nil of type %T", v) 15524 } 15525 var sv *types.HostedZoneNotEmpty 15526 if *v == nil { 15527 sv = &types.HostedZoneNotEmpty{} 15528 } else { 15529 sv = *v 15530 } 15531 15532 for { 15533 t, done, err := decoder.Token() 15534 if err != nil { 15535 return err 15536 } 15537 if done { 15538 break 15539 } 15540 originalDecoder := decoder 15541 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15542 switch { 15543 case strings.EqualFold("message", t.Name.Local): 15544 val, err := decoder.Value() 15545 if err != nil { 15546 return err 15547 } 15548 if val == nil { 15549 break 15550 } 15551 { 15552 xtv := string(val) 15553 sv.Message = ptr.String(xtv) 15554 } 15555 15556 default: 15557 // Do nothing and ignore the unexpected tag element 15558 err = decoder.Decoder.Skip() 15559 if err != nil { 15560 return err 15561 } 15562 15563 } 15564 decoder = originalDecoder 15565 } 15566 *v = sv 15567 return nil 15568} 15569 15570func awsRestxml_deserializeDocumentHostedZoneNotFound(v **types.HostedZoneNotFound, decoder smithyxml.NodeDecoder) error { 15571 if v == nil { 15572 return fmt.Errorf("unexpected nil of type %T", v) 15573 } 15574 var sv *types.HostedZoneNotFound 15575 if *v == nil { 15576 sv = &types.HostedZoneNotFound{} 15577 } else { 15578 sv = *v 15579 } 15580 15581 for { 15582 t, done, err := decoder.Token() 15583 if err != nil { 15584 return err 15585 } 15586 if done { 15587 break 15588 } 15589 originalDecoder := decoder 15590 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15591 switch { 15592 case strings.EqualFold("message", t.Name.Local): 15593 val, err := decoder.Value() 15594 if err != nil { 15595 return err 15596 } 15597 if val == nil { 15598 break 15599 } 15600 { 15601 xtv := string(val) 15602 sv.Message = ptr.String(xtv) 15603 } 15604 15605 default: 15606 // Do nothing and ignore the unexpected tag element 15607 err = decoder.Decoder.Skip() 15608 if err != nil { 15609 return err 15610 } 15611 15612 } 15613 decoder = originalDecoder 15614 } 15615 *v = sv 15616 return nil 15617} 15618 15619func awsRestxml_deserializeDocumentHostedZoneNotPrivate(v **types.HostedZoneNotPrivate, decoder smithyxml.NodeDecoder) error { 15620 if v == nil { 15621 return fmt.Errorf("unexpected nil of type %T", v) 15622 } 15623 var sv *types.HostedZoneNotPrivate 15624 if *v == nil { 15625 sv = &types.HostedZoneNotPrivate{} 15626 } else { 15627 sv = *v 15628 } 15629 15630 for { 15631 t, done, err := decoder.Token() 15632 if err != nil { 15633 return err 15634 } 15635 if done { 15636 break 15637 } 15638 originalDecoder := decoder 15639 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15640 switch { 15641 case strings.EqualFold("message", t.Name.Local): 15642 val, err := decoder.Value() 15643 if err != nil { 15644 return err 15645 } 15646 if val == nil { 15647 break 15648 } 15649 { 15650 xtv := string(val) 15651 sv.Message = ptr.String(xtv) 15652 } 15653 15654 default: 15655 // Do nothing and ignore the unexpected tag element 15656 err = decoder.Decoder.Skip() 15657 if err != nil { 15658 return err 15659 } 15660 15661 } 15662 decoder = originalDecoder 15663 } 15664 *v = sv 15665 return nil 15666} 15667 15668func awsRestxml_deserializeDocumentHostedZoneOwner(v **types.HostedZoneOwner, decoder smithyxml.NodeDecoder) error { 15669 if v == nil { 15670 return fmt.Errorf("unexpected nil of type %T", v) 15671 } 15672 var sv *types.HostedZoneOwner 15673 if *v == nil { 15674 sv = &types.HostedZoneOwner{} 15675 } else { 15676 sv = *v 15677 } 15678 15679 for { 15680 t, done, err := decoder.Token() 15681 if err != nil { 15682 return err 15683 } 15684 if done { 15685 break 15686 } 15687 originalDecoder := decoder 15688 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15689 switch { 15690 case strings.EqualFold("OwningAccount", t.Name.Local): 15691 val, err := decoder.Value() 15692 if err != nil { 15693 return err 15694 } 15695 if val == nil { 15696 break 15697 } 15698 { 15699 xtv := string(val) 15700 sv.OwningAccount = ptr.String(xtv) 15701 } 15702 15703 case strings.EqualFold("OwningService", t.Name.Local): 15704 val, err := decoder.Value() 15705 if err != nil { 15706 return err 15707 } 15708 if val == nil { 15709 break 15710 } 15711 { 15712 xtv := string(val) 15713 sv.OwningService = ptr.String(xtv) 15714 } 15715 15716 default: 15717 // Do nothing and ignore the unexpected tag element 15718 err = decoder.Decoder.Skip() 15719 if err != nil { 15720 return err 15721 } 15722 15723 } 15724 decoder = originalDecoder 15725 } 15726 *v = sv 15727 return nil 15728} 15729 15730func awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(v **types.HostedZonePartiallyDelegated, decoder smithyxml.NodeDecoder) error { 15731 if v == nil { 15732 return fmt.Errorf("unexpected nil of type %T", v) 15733 } 15734 var sv *types.HostedZonePartiallyDelegated 15735 if *v == nil { 15736 sv = &types.HostedZonePartiallyDelegated{} 15737 } else { 15738 sv = *v 15739 } 15740 15741 for { 15742 t, done, err := decoder.Token() 15743 if err != nil { 15744 return err 15745 } 15746 if done { 15747 break 15748 } 15749 originalDecoder := decoder 15750 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15751 switch { 15752 case strings.EqualFold("message", t.Name.Local): 15753 val, err := decoder.Value() 15754 if err != nil { 15755 return err 15756 } 15757 if val == nil { 15758 break 15759 } 15760 { 15761 xtv := string(val) 15762 sv.Message = ptr.String(xtv) 15763 } 15764 15765 default: 15766 // Do nothing and ignore the unexpected tag element 15767 err = decoder.Decoder.Skip() 15768 if err != nil { 15769 return err 15770 } 15771 15772 } 15773 decoder = originalDecoder 15774 } 15775 *v = sv 15776 return nil 15777} 15778 15779func awsRestxml_deserializeDocumentHostedZones(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error { 15780 if v == nil { 15781 return fmt.Errorf("unexpected nil of type %T", v) 15782 } 15783 var sv []types.HostedZone 15784 if *v == nil { 15785 sv = make([]types.HostedZone, 0) 15786 } else { 15787 sv = *v 15788 } 15789 15790 originalDecoder := decoder 15791 for { 15792 t, done, err := decoder.Token() 15793 if err != nil { 15794 return err 15795 } 15796 if done { 15797 break 15798 } 15799 switch { 15800 case strings.EqualFold("HostedZone", t.Name.Local): 15801 var col types.HostedZone 15802 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15803 destAddr := &col 15804 if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil { 15805 return err 15806 } 15807 col = *destAddr 15808 sv = append(sv, col) 15809 15810 default: 15811 err = decoder.Decoder.Skip() 15812 if err != nil { 15813 return err 15814 } 15815 15816 } 15817 decoder = originalDecoder 15818 } 15819 *v = sv 15820 return nil 15821} 15822 15823func awsRestxml_deserializeDocumentHostedZonesUnwrapped(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error { 15824 var sv []types.HostedZone 15825 if *v == nil { 15826 sv = make([]types.HostedZone, 0) 15827 } else { 15828 sv = *v 15829 } 15830 15831 switch { 15832 default: 15833 var mv types.HostedZone 15834 t := decoder.StartEl 15835 _ = t 15836 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15837 destAddr := &mv 15838 if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil { 15839 return err 15840 } 15841 mv = *destAddr 15842 sv = append(sv, mv) 15843 } 15844 *v = sv 15845 return nil 15846} 15847func awsRestxml_deserializeDocumentHostedZoneSummaries(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error { 15848 if v == nil { 15849 return fmt.Errorf("unexpected nil of type %T", v) 15850 } 15851 var sv []types.HostedZoneSummary 15852 if *v == nil { 15853 sv = make([]types.HostedZoneSummary, 0) 15854 } else { 15855 sv = *v 15856 } 15857 15858 originalDecoder := decoder 15859 for { 15860 t, done, err := decoder.Token() 15861 if err != nil { 15862 return err 15863 } 15864 if done { 15865 break 15866 } 15867 switch { 15868 case strings.EqualFold("HostedZoneSummary", t.Name.Local): 15869 var col types.HostedZoneSummary 15870 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15871 destAddr := &col 15872 if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil { 15873 return err 15874 } 15875 col = *destAddr 15876 sv = append(sv, col) 15877 15878 default: 15879 err = decoder.Decoder.Skip() 15880 if err != nil { 15881 return err 15882 } 15883 15884 } 15885 decoder = originalDecoder 15886 } 15887 *v = sv 15888 return nil 15889} 15890 15891func awsRestxml_deserializeDocumentHostedZoneSummariesUnwrapped(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error { 15892 var sv []types.HostedZoneSummary 15893 if *v == nil { 15894 sv = make([]types.HostedZoneSummary, 0) 15895 } else { 15896 sv = *v 15897 } 15898 15899 switch { 15900 default: 15901 var mv types.HostedZoneSummary 15902 t := decoder.StartEl 15903 _ = t 15904 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15905 destAddr := &mv 15906 if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil { 15907 return err 15908 } 15909 mv = *destAddr 15910 sv = append(sv, mv) 15911 } 15912 *v = sv 15913 return nil 15914} 15915func awsRestxml_deserializeDocumentHostedZoneSummary(v **types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error { 15916 if v == nil { 15917 return fmt.Errorf("unexpected nil of type %T", v) 15918 } 15919 var sv *types.HostedZoneSummary 15920 if *v == nil { 15921 sv = &types.HostedZoneSummary{} 15922 } else { 15923 sv = *v 15924 } 15925 15926 for { 15927 t, done, err := decoder.Token() 15928 if err != nil { 15929 return err 15930 } 15931 if done { 15932 break 15933 } 15934 originalDecoder := decoder 15935 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15936 switch { 15937 case strings.EqualFold("HostedZoneId", t.Name.Local): 15938 val, err := decoder.Value() 15939 if err != nil { 15940 return err 15941 } 15942 if val == nil { 15943 break 15944 } 15945 { 15946 xtv := string(val) 15947 sv.HostedZoneId = ptr.String(xtv) 15948 } 15949 15950 case strings.EqualFold("Name", t.Name.Local): 15951 val, err := decoder.Value() 15952 if err != nil { 15953 return err 15954 } 15955 if val == nil { 15956 break 15957 } 15958 { 15959 xtv := string(val) 15960 sv.Name = ptr.String(xtv) 15961 } 15962 15963 case strings.EqualFold("Owner", t.Name.Local): 15964 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15965 if err := awsRestxml_deserializeDocumentHostedZoneOwner(&sv.Owner, nodeDecoder); err != nil { 15966 return err 15967 } 15968 15969 default: 15970 // Do nothing and ignore the unexpected tag element 15971 err = decoder.Decoder.Skip() 15972 if err != nil { 15973 return err 15974 } 15975 15976 } 15977 decoder = originalDecoder 15978 } 15979 *v = sv 15980 return nil 15981} 15982 15983func awsRestxml_deserializeDocumentIncompatibleVersion(v **types.IncompatibleVersion, decoder smithyxml.NodeDecoder) error { 15984 if v == nil { 15985 return fmt.Errorf("unexpected nil of type %T", v) 15986 } 15987 var sv *types.IncompatibleVersion 15988 if *v == nil { 15989 sv = &types.IncompatibleVersion{} 15990 } else { 15991 sv = *v 15992 } 15993 15994 for { 15995 t, done, err := decoder.Token() 15996 if err != nil { 15997 return err 15998 } 15999 if done { 16000 break 16001 } 16002 originalDecoder := decoder 16003 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16004 switch { 16005 case strings.EqualFold("message", t.Name.Local): 16006 val, err := decoder.Value() 16007 if err != nil { 16008 return err 16009 } 16010 if val == nil { 16011 break 16012 } 16013 { 16014 xtv := string(val) 16015 sv.Message = ptr.String(xtv) 16016 } 16017 16018 default: 16019 // Do nothing and ignore the unexpected tag element 16020 err = decoder.Decoder.Skip() 16021 if err != nil { 16022 return err 16023 } 16024 16025 } 16026 decoder = originalDecoder 16027 } 16028 *v = sv 16029 return nil 16030} 16031 16032func awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(v **types.InsufficientCloudWatchLogsResourcePolicy, decoder smithyxml.NodeDecoder) error { 16033 if v == nil { 16034 return fmt.Errorf("unexpected nil of type %T", v) 16035 } 16036 var sv *types.InsufficientCloudWatchLogsResourcePolicy 16037 if *v == nil { 16038 sv = &types.InsufficientCloudWatchLogsResourcePolicy{} 16039 } else { 16040 sv = *v 16041 } 16042 16043 for { 16044 t, done, err := decoder.Token() 16045 if err != nil { 16046 return err 16047 } 16048 if done { 16049 break 16050 } 16051 originalDecoder := decoder 16052 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16053 switch { 16054 case strings.EqualFold("message", t.Name.Local): 16055 val, err := decoder.Value() 16056 if err != nil { 16057 return err 16058 } 16059 if val == nil { 16060 break 16061 } 16062 { 16063 xtv := string(val) 16064 sv.Message = ptr.String(xtv) 16065 } 16066 16067 default: 16068 // Do nothing and ignore the unexpected tag element 16069 err = decoder.Decoder.Skip() 16070 if err != nil { 16071 return err 16072 } 16073 16074 } 16075 decoder = originalDecoder 16076 } 16077 *v = sv 16078 return nil 16079} 16080 16081func awsRestxml_deserializeDocumentInvalidArgument(v **types.InvalidArgument, decoder smithyxml.NodeDecoder) error { 16082 if v == nil { 16083 return fmt.Errorf("unexpected nil of type %T", v) 16084 } 16085 var sv *types.InvalidArgument 16086 if *v == nil { 16087 sv = &types.InvalidArgument{} 16088 } else { 16089 sv = *v 16090 } 16091 16092 for { 16093 t, done, err := decoder.Token() 16094 if err != nil { 16095 return err 16096 } 16097 if done { 16098 break 16099 } 16100 originalDecoder := decoder 16101 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16102 switch { 16103 case strings.EqualFold("message", t.Name.Local): 16104 val, err := decoder.Value() 16105 if err != nil { 16106 return err 16107 } 16108 if val == nil { 16109 break 16110 } 16111 { 16112 xtv := string(val) 16113 sv.Message = ptr.String(xtv) 16114 } 16115 16116 default: 16117 // Do nothing and ignore the unexpected tag element 16118 err = decoder.Decoder.Skip() 16119 if err != nil { 16120 return err 16121 } 16122 16123 } 16124 decoder = originalDecoder 16125 } 16126 *v = sv 16127 return nil 16128} 16129 16130func awsRestxml_deserializeDocumentInvalidChangeBatch(v **types.InvalidChangeBatch, decoder smithyxml.NodeDecoder) error { 16131 if v == nil { 16132 return fmt.Errorf("unexpected nil of type %T", v) 16133 } 16134 var sv *types.InvalidChangeBatch 16135 if *v == nil { 16136 sv = &types.InvalidChangeBatch{} 16137 } else { 16138 sv = *v 16139 } 16140 16141 for { 16142 t, done, err := decoder.Token() 16143 if err != nil { 16144 return err 16145 } 16146 if done { 16147 break 16148 } 16149 originalDecoder := decoder 16150 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16151 switch { 16152 case strings.EqualFold("message", t.Name.Local): 16153 val, err := decoder.Value() 16154 if err != nil { 16155 return err 16156 } 16157 if val == nil { 16158 break 16159 } 16160 { 16161 xtv := string(val) 16162 sv.Message = ptr.String(xtv) 16163 } 16164 16165 case strings.EqualFold("messages", t.Name.Local): 16166 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16167 if err := awsRestxml_deserializeDocumentErrorMessages(&sv.Messages, nodeDecoder); err != nil { 16168 return err 16169 } 16170 16171 default: 16172 // Do nothing and ignore the unexpected tag element 16173 err = decoder.Decoder.Skip() 16174 if err != nil { 16175 return err 16176 } 16177 16178 } 16179 decoder = originalDecoder 16180 } 16181 *v = sv 16182 return nil 16183} 16184 16185func awsRestxml_deserializeDocumentInvalidDomainName(v **types.InvalidDomainName, decoder smithyxml.NodeDecoder) error { 16186 if v == nil { 16187 return fmt.Errorf("unexpected nil of type %T", v) 16188 } 16189 var sv *types.InvalidDomainName 16190 if *v == nil { 16191 sv = &types.InvalidDomainName{} 16192 } else { 16193 sv = *v 16194 } 16195 16196 for { 16197 t, done, err := decoder.Token() 16198 if err != nil { 16199 return err 16200 } 16201 if done { 16202 break 16203 } 16204 originalDecoder := decoder 16205 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16206 switch { 16207 case strings.EqualFold("message", t.Name.Local): 16208 val, err := decoder.Value() 16209 if err != nil { 16210 return err 16211 } 16212 if val == nil { 16213 break 16214 } 16215 { 16216 xtv := string(val) 16217 sv.Message = ptr.String(xtv) 16218 } 16219 16220 default: 16221 // Do nothing and ignore the unexpected tag element 16222 err = decoder.Decoder.Skip() 16223 if err != nil { 16224 return err 16225 } 16226 16227 } 16228 decoder = originalDecoder 16229 } 16230 *v = sv 16231 return nil 16232} 16233 16234func awsRestxml_deserializeDocumentInvalidInput(v **types.InvalidInput, decoder smithyxml.NodeDecoder) error { 16235 if v == nil { 16236 return fmt.Errorf("unexpected nil of type %T", v) 16237 } 16238 var sv *types.InvalidInput 16239 if *v == nil { 16240 sv = &types.InvalidInput{} 16241 } else { 16242 sv = *v 16243 } 16244 16245 for { 16246 t, done, err := decoder.Token() 16247 if err != nil { 16248 return err 16249 } 16250 if done { 16251 break 16252 } 16253 originalDecoder := decoder 16254 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16255 switch { 16256 case strings.EqualFold("message", t.Name.Local): 16257 val, err := decoder.Value() 16258 if err != nil { 16259 return err 16260 } 16261 if val == nil { 16262 break 16263 } 16264 { 16265 xtv := string(val) 16266 sv.Message = ptr.String(xtv) 16267 } 16268 16269 default: 16270 // Do nothing and ignore the unexpected tag element 16271 err = decoder.Decoder.Skip() 16272 if err != nil { 16273 return err 16274 } 16275 16276 } 16277 decoder = originalDecoder 16278 } 16279 *v = sv 16280 return nil 16281} 16282 16283func awsRestxml_deserializeDocumentInvalidKeySigningKeyName(v **types.InvalidKeySigningKeyName, decoder smithyxml.NodeDecoder) error { 16284 if v == nil { 16285 return fmt.Errorf("unexpected nil of type %T", v) 16286 } 16287 var sv *types.InvalidKeySigningKeyName 16288 if *v == nil { 16289 sv = &types.InvalidKeySigningKeyName{} 16290 } else { 16291 sv = *v 16292 } 16293 16294 for { 16295 t, done, err := decoder.Token() 16296 if err != nil { 16297 return err 16298 } 16299 if done { 16300 break 16301 } 16302 originalDecoder := decoder 16303 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16304 switch { 16305 case strings.EqualFold("message", t.Name.Local): 16306 val, err := decoder.Value() 16307 if err != nil { 16308 return err 16309 } 16310 if val == nil { 16311 break 16312 } 16313 { 16314 xtv := string(val) 16315 sv.Message = ptr.String(xtv) 16316 } 16317 16318 default: 16319 // Do nothing and ignore the unexpected tag element 16320 err = decoder.Decoder.Skip() 16321 if err != nil { 16322 return err 16323 } 16324 16325 } 16326 decoder = originalDecoder 16327 } 16328 *v = sv 16329 return nil 16330} 16331 16332func awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(v **types.InvalidKeySigningKeyStatus, decoder smithyxml.NodeDecoder) error { 16333 if v == nil { 16334 return fmt.Errorf("unexpected nil of type %T", v) 16335 } 16336 var sv *types.InvalidKeySigningKeyStatus 16337 if *v == nil { 16338 sv = &types.InvalidKeySigningKeyStatus{} 16339 } else { 16340 sv = *v 16341 } 16342 16343 for { 16344 t, done, err := decoder.Token() 16345 if err != nil { 16346 return err 16347 } 16348 if done { 16349 break 16350 } 16351 originalDecoder := decoder 16352 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16353 switch { 16354 case strings.EqualFold("message", t.Name.Local): 16355 val, err := decoder.Value() 16356 if err != nil { 16357 return err 16358 } 16359 if val == nil { 16360 break 16361 } 16362 { 16363 xtv := string(val) 16364 sv.Message = ptr.String(xtv) 16365 } 16366 16367 default: 16368 // Do nothing and ignore the unexpected tag element 16369 err = decoder.Decoder.Skip() 16370 if err != nil { 16371 return err 16372 } 16373 16374 } 16375 decoder = originalDecoder 16376 } 16377 *v = sv 16378 return nil 16379} 16380 16381func awsRestxml_deserializeDocumentInvalidKMSArn(v **types.InvalidKMSArn, decoder smithyxml.NodeDecoder) error { 16382 if v == nil { 16383 return fmt.Errorf("unexpected nil of type %T", v) 16384 } 16385 var sv *types.InvalidKMSArn 16386 if *v == nil { 16387 sv = &types.InvalidKMSArn{} 16388 } else { 16389 sv = *v 16390 } 16391 16392 for { 16393 t, done, err := decoder.Token() 16394 if err != nil { 16395 return err 16396 } 16397 if done { 16398 break 16399 } 16400 originalDecoder := decoder 16401 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16402 switch { 16403 case strings.EqualFold("message", t.Name.Local): 16404 val, err := decoder.Value() 16405 if err != nil { 16406 return err 16407 } 16408 if val == nil { 16409 break 16410 } 16411 { 16412 xtv := string(val) 16413 sv.Message = ptr.String(xtv) 16414 } 16415 16416 default: 16417 // Do nothing and ignore the unexpected tag element 16418 err = decoder.Decoder.Skip() 16419 if err != nil { 16420 return err 16421 } 16422 16423 } 16424 decoder = originalDecoder 16425 } 16426 *v = sv 16427 return nil 16428} 16429 16430func awsRestxml_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, decoder smithyxml.NodeDecoder) error { 16431 if v == nil { 16432 return fmt.Errorf("unexpected nil of type %T", v) 16433 } 16434 var sv *types.InvalidPaginationToken 16435 if *v == nil { 16436 sv = &types.InvalidPaginationToken{} 16437 } else { 16438 sv = *v 16439 } 16440 16441 for { 16442 t, done, err := decoder.Token() 16443 if err != nil { 16444 return err 16445 } 16446 if done { 16447 break 16448 } 16449 originalDecoder := decoder 16450 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16451 switch { 16452 case strings.EqualFold("message", t.Name.Local): 16453 val, err := decoder.Value() 16454 if err != nil { 16455 return err 16456 } 16457 if val == nil { 16458 break 16459 } 16460 { 16461 xtv := string(val) 16462 sv.Message = ptr.String(xtv) 16463 } 16464 16465 default: 16466 // Do nothing and ignore the unexpected tag element 16467 err = decoder.Decoder.Skip() 16468 if err != nil { 16469 return err 16470 } 16471 16472 } 16473 decoder = originalDecoder 16474 } 16475 *v = sv 16476 return nil 16477} 16478 16479func awsRestxml_deserializeDocumentInvalidSigningStatus(v **types.InvalidSigningStatus, decoder smithyxml.NodeDecoder) error { 16480 if v == nil { 16481 return fmt.Errorf("unexpected nil of type %T", v) 16482 } 16483 var sv *types.InvalidSigningStatus 16484 if *v == nil { 16485 sv = &types.InvalidSigningStatus{} 16486 } else { 16487 sv = *v 16488 } 16489 16490 for { 16491 t, done, err := decoder.Token() 16492 if err != nil { 16493 return err 16494 } 16495 if done { 16496 break 16497 } 16498 originalDecoder := decoder 16499 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16500 switch { 16501 case strings.EqualFold("message", t.Name.Local): 16502 val, err := decoder.Value() 16503 if err != nil { 16504 return err 16505 } 16506 if val == nil { 16507 break 16508 } 16509 { 16510 xtv := string(val) 16511 sv.Message = ptr.String(xtv) 16512 } 16513 16514 default: 16515 // Do nothing and ignore the unexpected tag element 16516 err = decoder.Decoder.Skip() 16517 if err != nil { 16518 return err 16519 } 16520 16521 } 16522 decoder = originalDecoder 16523 } 16524 *v = sv 16525 return nil 16526} 16527 16528func awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(v **types.InvalidTrafficPolicyDocument, decoder smithyxml.NodeDecoder) error { 16529 if v == nil { 16530 return fmt.Errorf("unexpected nil of type %T", v) 16531 } 16532 var sv *types.InvalidTrafficPolicyDocument 16533 if *v == nil { 16534 sv = &types.InvalidTrafficPolicyDocument{} 16535 } else { 16536 sv = *v 16537 } 16538 16539 for { 16540 t, done, err := decoder.Token() 16541 if err != nil { 16542 return err 16543 } 16544 if done { 16545 break 16546 } 16547 originalDecoder := decoder 16548 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16549 switch { 16550 case strings.EqualFold("message", t.Name.Local): 16551 val, err := decoder.Value() 16552 if err != nil { 16553 return err 16554 } 16555 if val == nil { 16556 break 16557 } 16558 { 16559 xtv := string(val) 16560 sv.Message = ptr.String(xtv) 16561 } 16562 16563 default: 16564 // Do nothing and ignore the unexpected tag element 16565 err = decoder.Decoder.Skip() 16566 if err != nil { 16567 return err 16568 } 16569 16570 } 16571 decoder = originalDecoder 16572 } 16573 *v = sv 16574 return nil 16575} 16576 16577func awsRestxml_deserializeDocumentInvalidVPCId(v **types.InvalidVPCId, decoder smithyxml.NodeDecoder) error { 16578 if v == nil { 16579 return fmt.Errorf("unexpected nil of type %T", v) 16580 } 16581 var sv *types.InvalidVPCId 16582 if *v == nil { 16583 sv = &types.InvalidVPCId{} 16584 } else { 16585 sv = *v 16586 } 16587 16588 for { 16589 t, done, err := decoder.Token() 16590 if err != nil { 16591 return err 16592 } 16593 if done { 16594 break 16595 } 16596 originalDecoder := decoder 16597 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16598 switch { 16599 case strings.EqualFold("message", t.Name.Local): 16600 val, err := decoder.Value() 16601 if err != nil { 16602 return err 16603 } 16604 if val == nil { 16605 break 16606 } 16607 { 16608 xtv := string(val) 16609 sv.Message = ptr.String(xtv) 16610 } 16611 16612 default: 16613 // Do nothing and ignore the unexpected tag element 16614 err = decoder.Decoder.Skip() 16615 if err != nil { 16616 return err 16617 } 16618 16619 } 16620 decoder = originalDecoder 16621 } 16622 *v = sv 16623 return nil 16624} 16625 16626func awsRestxml_deserializeDocumentKeySigningKey(v **types.KeySigningKey, decoder smithyxml.NodeDecoder) error { 16627 if v == nil { 16628 return fmt.Errorf("unexpected nil of type %T", v) 16629 } 16630 var sv *types.KeySigningKey 16631 if *v == nil { 16632 sv = &types.KeySigningKey{} 16633 } else { 16634 sv = *v 16635 } 16636 16637 for { 16638 t, done, err := decoder.Token() 16639 if err != nil { 16640 return err 16641 } 16642 if done { 16643 break 16644 } 16645 originalDecoder := decoder 16646 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16647 switch { 16648 case strings.EqualFold("CreatedDate", t.Name.Local): 16649 val, err := decoder.Value() 16650 if err != nil { 16651 return err 16652 } 16653 if val == nil { 16654 break 16655 } 16656 { 16657 xtv := string(val) 16658 t, err := smithytime.ParseDateTime(xtv) 16659 if err != nil { 16660 return err 16661 } 16662 sv.CreatedDate = ptr.Time(t) 16663 } 16664 16665 case strings.EqualFold("DigestAlgorithmMnemonic", t.Name.Local): 16666 val, err := decoder.Value() 16667 if err != nil { 16668 return err 16669 } 16670 if val == nil { 16671 break 16672 } 16673 { 16674 xtv := string(val) 16675 sv.DigestAlgorithmMnemonic = ptr.String(xtv) 16676 } 16677 16678 case strings.EqualFold("DigestAlgorithmType", t.Name.Local): 16679 val, err := decoder.Value() 16680 if err != nil { 16681 return err 16682 } 16683 if val == nil { 16684 break 16685 } 16686 { 16687 xtv := string(val) 16688 i64, err := strconv.ParseInt(xtv, 10, 64) 16689 if err != nil { 16690 return err 16691 } 16692 sv.DigestAlgorithmType = int32(i64) 16693 } 16694 16695 case strings.EqualFold("DigestValue", t.Name.Local): 16696 val, err := decoder.Value() 16697 if err != nil { 16698 return err 16699 } 16700 if val == nil { 16701 break 16702 } 16703 { 16704 xtv := string(val) 16705 sv.DigestValue = ptr.String(xtv) 16706 } 16707 16708 case strings.EqualFold("DNSKEYRecord", t.Name.Local): 16709 val, err := decoder.Value() 16710 if err != nil { 16711 return err 16712 } 16713 if val == nil { 16714 break 16715 } 16716 { 16717 xtv := string(val) 16718 sv.DNSKEYRecord = ptr.String(xtv) 16719 } 16720 16721 case strings.EqualFold("DSRecord", t.Name.Local): 16722 val, err := decoder.Value() 16723 if err != nil { 16724 return err 16725 } 16726 if val == nil { 16727 break 16728 } 16729 { 16730 xtv := string(val) 16731 sv.DSRecord = ptr.String(xtv) 16732 } 16733 16734 case strings.EqualFold("Flag", t.Name.Local): 16735 val, err := decoder.Value() 16736 if err != nil { 16737 return err 16738 } 16739 if val == nil { 16740 break 16741 } 16742 { 16743 xtv := string(val) 16744 i64, err := strconv.ParseInt(xtv, 10, 64) 16745 if err != nil { 16746 return err 16747 } 16748 sv.Flag = int32(i64) 16749 } 16750 16751 case strings.EqualFold("KeyTag", t.Name.Local): 16752 val, err := decoder.Value() 16753 if err != nil { 16754 return err 16755 } 16756 if val == nil { 16757 break 16758 } 16759 { 16760 xtv := string(val) 16761 i64, err := strconv.ParseInt(xtv, 10, 64) 16762 if err != nil { 16763 return err 16764 } 16765 sv.KeyTag = int32(i64) 16766 } 16767 16768 case strings.EqualFold("KmsArn", t.Name.Local): 16769 val, err := decoder.Value() 16770 if err != nil { 16771 return err 16772 } 16773 if val == nil { 16774 break 16775 } 16776 { 16777 xtv := string(val) 16778 sv.KmsArn = ptr.String(xtv) 16779 } 16780 16781 case strings.EqualFold("LastModifiedDate", t.Name.Local): 16782 val, err := decoder.Value() 16783 if err != nil { 16784 return err 16785 } 16786 if val == nil { 16787 break 16788 } 16789 { 16790 xtv := string(val) 16791 t, err := smithytime.ParseDateTime(xtv) 16792 if err != nil { 16793 return err 16794 } 16795 sv.LastModifiedDate = ptr.Time(t) 16796 } 16797 16798 case strings.EqualFold("Name", t.Name.Local): 16799 val, err := decoder.Value() 16800 if err != nil { 16801 return err 16802 } 16803 if val == nil { 16804 break 16805 } 16806 { 16807 xtv := string(val) 16808 sv.Name = ptr.String(xtv) 16809 } 16810 16811 case strings.EqualFold("PublicKey", t.Name.Local): 16812 val, err := decoder.Value() 16813 if err != nil { 16814 return err 16815 } 16816 if val == nil { 16817 break 16818 } 16819 { 16820 xtv := string(val) 16821 sv.PublicKey = ptr.String(xtv) 16822 } 16823 16824 case strings.EqualFold("SigningAlgorithmMnemonic", t.Name.Local): 16825 val, err := decoder.Value() 16826 if err != nil { 16827 return err 16828 } 16829 if val == nil { 16830 break 16831 } 16832 { 16833 xtv := string(val) 16834 sv.SigningAlgorithmMnemonic = ptr.String(xtv) 16835 } 16836 16837 case strings.EqualFold("SigningAlgorithmType", t.Name.Local): 16838 val, err := decoder.Value() 16839 if err != nil { 16840 return err 16841 } 16842 if val == nil { 16843 break 16844 } 16845 { 16846 xtv := string(val) 16847 i64, err := strconv.ParseInt(xtv, 10, 64) 16848 if err != nil { 16849 return err 16850 } 16851 sv.SigningAlgorithmType = int32(i64) 16852 } 16853 16854 case strings.EqualFold("Status", t.Name.Local): 16855 val, err := decoder.Value() 16856 if err != nil { 16857 return err 16858 } 16859 if val == nil { 16860 break 16861 } 16862 { 16863 xtv := string(val) 16864 sv.Status = ptr.String(xtv) 16865 } 16866 16867 case strings.EqualFold("StatusMessage", t.Name.Local): 16868 val, err := decoder.Value() 16869 if err != nil { 16870 return err 16871 } 16872 if val == nil { 16873 break 16874 } 16875 { 16876 xtv := string(val) 16877 sv.StatusMessage = ptr.String(xtv) 16878 } 16879 16880 default: 16881 // Do nothing and ignore the unexpected tag element 16882 err = decoder.Decoder.Skip() 16883 if err != nil { 16884 return err 16885 } 16886 16887 } 16888 decoder = originalDecoder 16889 } 16890 *v = sv 16891 return nil 16892} 16893 16894func awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(v **types.KeySigningKeyAlreadyExists, decoder smithyxml.NodeDecoder) error { 16895 if v == nil { 16896 return fmt.Errorf("unexpected nil of type %T", v) 16897 } 16898 var sv *types.KeySigningKeyAlreadyExists 16899 if *v == nil { 16900 sv = &types.KeySigningKeyAlreadyExists{} 16901 } else { 16902 sv = *v 16903 } 16904 16905 for { 16906 t, done, err := decoder.Token() 16907 if err != nil { 16908 return err 16909 } 16910 if done { 16911 break 16912 } 16913 originalDecoder := decoder 16914 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16915 switch { 16916 case strings.EqualFold("message", t.Name.Local): 16917 val, err := decoder.Value() 16918 if err != nil { 16919 return err 16920 } 16921 if val == nil { 16922 break 16923 } 16924 { 16925 xtv := string(val) 16926 sv.Message = ptr.String(xtv) 16927 } 16928 16929 default: 16930 // Do nothing and ignore the unexpected tag element 16931 err = decoder.Decoder.Skip() 16932 if err != nil { 16933 return err 16934 } 16935 16936 } 16937 decoder = originalDecoder 16938 } 16939 *v = sv 16940 return nil 16941} 16942 16943func awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(v **types.KeySigningKeyInParentDSRecord, decoder smithyxml.NodeDecoder) error { 16944 if v == nil { 16945 return fmt.Errorf("unexpected nil of type %T", v) 16946 } 16947 var sv *types.KeySigningKeyInParentDSRecord 16948 if *v == nil { 16949 sv = &types.KeySigningKeyInParentDSRecord{} 16950 } else { 16951 sv = *v 16952 } 16953 16954 for { 16955 t, done, err := decoder.Token() 16956 if err != nil { 16957 return err 16958 } 16959 if done { 16960 break 16961 } 16962 originalDecoder := decoder 16963 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16964 switch { 16965 case strings.EqualFold("message", t.Name.Local): 16966 val, err := decoder.Value() 16967 if err != nil { 16968 return err 16969 } 16970 if val == nil { 16971 break 16972 } 16973 { 16974 xtv := string(val) 16975 sv.Message = ptr.String(xtv) 16976 } 16977 16978 default: 16979 // Do nothing and ignore the unexpected tag element 16980 err = decoder.Decoder.Skip() 16981 if err != nil { 16982 return err 16983 } 16984 16985 } 16986 decoder = originalDecoder 16987 } 16988 *v = sv 16989 return nil 16990} 16991 16992func awsRestxml_deserializeDocumentKeySigningKeyInUse(v **types.KeySigningKeyInUse, decoder smithyxml.NodeDecoder) error { 16993 if v == nil { 16994 return fmt.Errorf("unexpected nil of type %T", v) 16995 } 16996 var sv *types.KeySigningKeyInUse 16997 if *v == nil { 16998 sv = &types.KeySigningKeyInUse{} 16999 } else { 17000 sv = *v 17001 } 17002 17003 for { 17004 t, done, err := decoder.Token() 17005 if err != nil { 17006 return err 17007 } 17008 if done { 17009 break 17010 } 17011 originalDecoder := decoder 17012 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17013 switch { 17014 case strings.EqualFold("message", t.Name.Local): 17015 val, err := decoder.Value() 17016 if err != nil { 17017 return err 17018 } 17019 if val == nil { 17020 break 17021 } 17022 { 17023 xtv := string(val) 17024 sv.Message = ptr.String(xtv) 17025 } 17026 17027 default: 17028 // Do nothing and ignore the unexpected tag element 17029 err = decoder.Decoder.Skip() 17030 if err != nil { 17031 return err 17032 } 17033 17034 } 17035 decoder = originalDecoder 17036 } 17037 *v = sv 17038 return nil 17039} 17040 17041func awsRestxml_deserializeDocumentKeySigningKeys(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error { 17042 if v == nil { 17043 return fmt.Errorf("unexpected nil of type %T", v) 17044 } 17045 var sv []types.KeySigningKey 17046 if *v == nil { 17047 sv = make([]types.KeySigningKey, 0) 17048 } else { 17049 sv = *v 17050 } 17051 17052 originalDecoder := decoder 17053 for { 17054 t, done, err := decoder.Token() 17055 if err != nil { 17056 return err 17057 } 17058 if done { 17059 break 17060 } 17061 switch { 17062 case strings.EqualFold("member", t.Name.Local): 17063 var col types.KeySigningKey 17064 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17065 destAddr := &col 17066 if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil { 17067 return err 17068 } 17069 col = *destAddr 17070 sv = append(sv, col) 17071 17072 default: 17073 err = decoder.Decoder.Skip() 17074 if err != nil { 17075 return err 17076 } 17077 17078 } 17079 decoder = originalDecoder 17080 } 17081 *v = sv 17082 return nil 17083} 17084 17085func awsRestxml_deserializeDocumentKeySigningKeysUnwrapped(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error { 17086 var sv []types.KeySigningKey 17087 if *v == nil { 17088 sv = make([]types.KeySigningKey, 0) 17089 } else { 17090 sv = *v 17091 } 17092 17093 switch { 17094 default: 17095 var mv types.KeySigningKey 17096 t := decoder.StartEl 17097 _ = t 17098 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17099 destAddr := &mv 17100 if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil { 17101 return err 17102 } 17103 mv = *destAddr 17104 sv = append(sv, mv) 17105 } 17106 *v = sv 17107 return nil 17108} 17109func awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(v **types.KeySigningKeyWithActiveStatusNotFound, decoder smithyxml.NodeDecoder) error { 17110 if v == nil { 17111 return fmt.Errorf("unexpected nil of type %T", v) 17112 } 17113 var sv *types.KeySigningKeyWithActiveStatusNotFound 17114 if *v == nil { 17115 sv = &types.KeySigningKeyWithActiveStatusNotFound{} 17116 } else { 17117 sv = *v 17118 } 17119 17120 for { 17121 t, done, err := decoder.Token() 17122 if err != nil { 17123 return err 17124 } 17125 if done { 17126 break 17127 } 17128 originalDecoder := decoder 17129 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17130 switch { 17131 case strings.EqualFold("message", t.Name.Local): 17132 val, err := decoder.Value() 17133 if err != nil { 17134 return err 17135 } 17136 if val == nil { 17137 break 17138 } 17139 { 17140 xtv := string(val) 17141 sv.Message = ptr.String(xtv) 17142 } 17143 17144 default: 17145 // Do nothing and ignore the unexpected tag element 17146 err = decoder.Decoder.Skip() 17147 if err != nil { 17148 return err 17149 } 17150 17151 } 17152 decoder = originalDecoder 17153 } 17154 *v = sv 17155 return nil 17156} 17157 17158func awsRestxml_deserializeDocumentLastVPCAssociation(v **types.LastVPCAssociation, decoder smithyxml.NodeDecoder) error { 17159 if v == nil { 17160 return fmt.Errorf("unexpected nil of type %T", v) 17161 } 17162 var sv *types.LastVPCAssociation 17163 if *v == nil { 17164 sv = &types.LastVPCAssociation{} 17165 } else { 17166 sv = *v 17167 } 17168 17169 for { 17170 t, done, err := decoder.Token() 17171 if err != nil { 17172 return err 17173 } 17174 if done { 17175 break 17176 } 17177 originalDecoder := decoder 17178 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17179 switch { 17180 case strings.EqualFold("message", t.Name.Local): 17181 val, err := decoder.Value() 17182 if err != nil { 17183 return err 17184 } 17185 if val == nil { 17186 break 17187 } 17188 { 17189 xtv := string(val) 17190 sv.Message = ptr.String(xtv) 17191 } 17192 17193 default: 17194 // Do nothing and ignore the unexpected tag element 17195 err = decoder.Decoder.Skip() 17196 if err != nil { 17197 return err 17198 } 17199 17200 } 17201 decoder = originalDecoder 17202 } 17203 *v = sv 17204 return nil 17205} 17206 17207func awsRestxml_deserializeDocumentLimitsExceeded(v **types.LimitsExceeded, decoder smithyxml.NodeDecoder) error { 17208 if v == nil { 17209 return fmt.Errorf("unexpected nil of type %T", v) 17210 } 17211 var sv *types.LimitsExceeded 17212 if *v == nil { 17213 sv = &types.LimitsExceeded{} 17214 } else { 17215 sv = *v 17216 } 17217 17218 for { 17219 t, done, err := decoder.Token() 17220 if err != nil { 17221 return err 17222 } 17223 if done { 17224 break 17225 } 17226 originalDecoder := decoder 17227 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17228 switch { 17229 case strings.EqualFold("message", t.Name.Local): 17230 val, err := decoder.Value() 17231 if err != nil { 17232 return err 17233 } 17234 if val == nil { 17235 break 17236 } 17237 { 17238 xtv := string(val) 17239 sv.Message = ptr.String(xtv) 17240 } 17241 17242 default: 17243 // Do nothing and ignore the unexpected tag element 17244 err = decoder.Decoder.Skip() 17245 if err != nil { 17246 return err 17247 } 17248 17249 } 17250 decoder = originalDecoder 17251 } 17252 *v = sv 17253 return nil 17254} 17255 17256func awsRestxml_deserializeDocumentLinkedService(v **types.LinkedService, decoder smithyxml.NodeDecoder) error { 17257 if v == nil { 17258 return fmt.Errorf("unexpected nil of type %T", v) 17259 } 17260 var sv *types.LinkedService 17261 if *v == nil { 17262 sv = &types.LinkedService{} 17263 } else { 17264 sv = *v 17265 } 17266 17267 for { 17268 t, done, err := decoder.Token() 17269 if err != nil { 17270 return err 17271 } 17272 if done { 17273 break 17274 } 17275 originalDecoder := decoder 17276 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17277 switch { 17278 case strings.EqualFold("Description", t.Name.Local): 17279 val, err := decoder.Value() 17280 if err != nil { 17281 return err 17282 } 17283 if val == nil { 17284 break 17285 } 17286 { 17287 xtv := string(val) 17288 sv.Description = ptr.String(xtv) 17289 } 17290 17291 case strings.EqualFold("ServicePrincipal", t.Name.Local): 17292 val, err := decoder.Value() 17293 if err != nil { 17294 return err 17295 } 17296 if val == nil { 17297 break 17298 } 17299 { 17300 xtv := string(val) 17301 sv.ServicePrincipal = ptr.String(xtv) 17302 } 17303 17304 default: 17305 // Do nothing and ignore the unexpected tag element 17306 err = decoder.Decoder.Skip() 17307 if err != nil { 17308 return err 17309 } 17310 17311 } 17312 decoder = originalDecoder 17313 } 17314 *v = sv 17315 return nil 17316} 17317 17318func awsRestxml_deserializeDocumentNoSuchChange(v **types.NoSuchChange, decoder smithyxml.NodeDecoder) error { 17319 if v == nil { 17320 return fmt.Errorf("unexpected nil of type %T", v) 17321 } 17322 var sv *types.NoSuchChange 17323 if *v == nil { 17324 sv = &types.NoSuchChange{} 17325 } else { 17326 sv = *v 17327 } 17328 17329 for { 17330 t, done, err := decoder.Token() 17331 if err != nil { 17332 return err 17333 } 17334 if done { 17335 break 17336 } 17337 originalDecoder := decoder 17338 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17339 switch { 17340 case strings.EqualFold("message", t.Name.Local): 17341 val, err := decoder.Value() 17342 if err != nil { 17343 return err 17344 } 17345 if val == nil { 17346 break 17347 } 17348 { 17349 xtv := string(val) 17350 sv.Message = ptr.String(xtv) 17351 } 17352 17353 default: 17354 // Do nothing and ignore the unexpected tag element 17355 err = decoder.Decoder.Skip() 17356 if err != nil { 17357 return err 17358 } 17359 17360 } 17361 decoder = originalDecoder 17362 } 17363 *v = sv 17364 return nil 17365} 17366 17367func awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(v **types.NoSuchCloudWatchLogsLogGroup, decoder smithyxml.NodeDecoder) error { 17368 if v == nil { 17369 return fmt.Errorf("unexpected nil of type %T", v) 17370 } 17371 var sv *types.NoSuchCloudWatchLogsLogGroup 17372 if *v == nil { 17373 sv = &types.NoSuchCloudWatchLogsLogGroup{} 17374 } else { 17375 sv = *v 17376 } 17377 17378 for { 17379 t, done, err := decoder.Token() 17380 if err != nil { 17381 return err 17382 } 17383 if done { 17384 break 17385 } 17386 originalDecoder := decoder 17387 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17388 switch { 17389 case strings.EqualFold("message", t.Name.Local): 17390 val, err := decoder.Value() 17391 if err != nil { 17392 return err 17393 } 17394 if val == nil { 17395 break 17396 } 17397 { 17398 xtv := string(val) 17399 sv.Message = ptr.String(xtv) 17400 } 17401 17402 default: 17403 // Do nothing and ignore the unexpected tag element 17404 err = decoder.Decoder.Skip() 17405 if err != nil { 17406 return err 17407 } 17408 17409 } 17410 decoder = originalDecoder 17411 } 17412 *v = sv 17413 return nil 17414} 17415 17416func awsRestxml_deserializeDocumentNoSuchDelegationSet(v **types.NoSuchDelegationSet, decoder smithyxml.NodeDecoder) error { 17417 if v == nil { 17418 return fmt.Errorf("unexpected nil of type %T", v) 17419 } 17420 var sv *types.NoSuchDelegationSet 17421 if *v == nil { 17422 sv = &types.NoSuchDelegationSet{} 17423 } else { 17424 sv = *v 17425 } 17426 17427 for { 17428 t, done, err := decoder.Token() 17429 if err != nil { 17430 return err 17431 } 17432 if done { 17433 break 17434 } 17435 originalDecoder := decoder 17436 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17437 switch { 17438 case strings.EqualFold("message", t.Name.Local): 17439 val, err := decoder.Value() 17440 if err != nil { 17441 return err 17442 } 17443 if val == nil { 17444 break 17445 } 17446 { 17447 xtv := string(val) 17448 sv.Message = ptr.String(xtv) 17449 } 17450 17451 default: 17452 // Do nothing and ignore the unexpected tag element 17453 err = decoder.Decoder.Skip() 17454 if err != nil { 17455 return err 17456 } 17457 17458 } 17459 decoder = originalDecoder 17460 } 17461 *v = sv 17462 return nil 17463} 17464 17465func awsRestxml_deserializeDocumentNoSuchGeoLocation(v **types.NoSuchGeoLocation, decoder smithyxml.NodeDecoder) error { 17466 if v == nil { 17467 return fmt.Errorf("unexpected nil of type %T", v) 17468 } 17469 var sv *types.NoSuchGeoLocation 17470 if *v == nil { 17471 sv = &types.NoSuchGeoLocation{} 17472 } else { 17473 sv = *v 17474 } 17475 17476 for { 17477 t, done, err := decoder.Token() 17478 if err != nil { 17479 return err 17480 } 17481 if done { 17482 break 17483 } 17484 originalDecoder := decoder 17485 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17486 switch { 17487 case strings.EqualFold("message", t.Name.Local): 17488 val, err := decoder.Value() 17489 if err != nil { 17490 return err 17491 } 17492 if val == nil { 17493 break 17494 } 17495 { 17496 xtv := string(val) 17497 sv.Message = ptr.String(xtv) 17498 } 17499 17500 default: 17501 // Do nothing and ignore the unexpected tag element 17502 err = decoder.Decoder.Skip() 17503 if err != nil { 17504 return err 17505 } 17506 17507 } 17508 decoder = originalDecoder 17509 } 17510 *v = sv 17511 return nil 17512} 17513 17514func awsRestxml_deserializeDocumentNoSuchHealthCheck(v **types.NoSuchHealthCheck, decoder smithyxml.NodeDecoder) error { 17515 if v == nil { 17516 return fmt.Errorf("unexpected nil of type %T", v) 17517 } 17518 var sv *types.NoSuchHealthCheck 17519 if *v == nil { 17520 sv = &types.NoSuchHealthCheck{} 17521 } else { 17522 sv = *v 17523 } 17524 17525 for { 17526 t, done, err := decoder.Token() 17527 if err != nil { 17528 return err 17529 } 17530 if done { 17531 break 17532 } 17533 originalDecoder := decoder 17534 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17535 switch { 17536 case strings.EqualFold("message", t.Name.Local): 17537 val, err := decoder.Value() 17538 if err != nil { 17539 return err 17540 } 17541 if val == nil { 17542 break 17543 } 17544 { 17545 xtv := string(val) 17546 sv.Message = ptr.String(xtv) 17547 } 17548 17549 default: 17550 // Do nothing and ignore the unexpected tag element 17551 err = decoder.Decoder.Skip() 17552 if err != nil { 17553 return err 17554 } 17555 17556 } 17557 decoder = originalDecoder 17558 } 17559 *v = sv 17560 return nil 17561} 17562 17563func awsRestxml_deserializeDocumentNoSuchHostedZone(v **types.NoSuchHostedZone, decoder smithyxml.NodeDecoder) error { 17564 if v == nil { 17565 return fmt.Errorf("unexpected nil of type %T", v) 17566 } 17567 var sv *types.NoSuchHostedZone 17568 if *v == nil { 17569 sv = &types.NoSuchHostedZone{} 17570 } else { 17571 sv = *v 17572 } 17573 17574 for { 17575 t, done, err := decoder.Token() 17576 if err != nil { 17577 return err 17578 } 17579 if done { 17580 break 17581 } 17582 originalDecoder := decoder 17583 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17584 switch { 17585 case strings.EqualFold("message", t.Name.Local): 17586 val, err := decoder.Value() 17587 if err != nil { 17588 return err 17589 } 17590 if val == nil { 17591 break 17592 } 17593 { 17594 xtv := string(val) 17595 sv.Message = ptr.String(xtv) 17596 } 17597 17598 default: 17599 // Do nothing and ignore the unexpected tag element 17600 err = decoder.Decoder.Skip() 17601 if err != nil { 17602 return err 17603 } 17604 17605 } 17606 decoder = originalDecoder 17607 } 17608 *v = sv 17609 return nil 17610} 17611 17612func awsRestxml_deserializeDocumentNoSuchKeySigningKey(v **types.NoSuchKeySigningKey, decoder smithyxml.NodeDecoder) error { 17613 if v == nil { 17614 return fmt.Errorf("unexpected nil of type %T", v) 17615 } 17616 var sv *types.NoSuchKeySigningKey 17617 if *v == nil { 17618 sv = &types.NoSuchKeySigningKey{} 17619 } else { 17620 sv = *v 17621 } 17622 17623 for { 17624 t, done, err := decoder.Token() 17625 if err != nil { 17626 return err 17627 } 17628 if done { 17629 break 17630 } 17631 originalDecoder := decoder 17632 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17633 switch { 17634 case strings.EqualFold("message", t.Name.Local): 17635 val, err := decoder.Value() 17636 if err != nil { 17637 return err 17638 } 17639 if val == nil { 17640 break 17641 } 17642 { 17643 xtv := string(val) 17644 sv.Message = ptr.String(xtv) 17645 } 17646 17647 default: 17648 // Do nothing and ignore the unexpected tag element 17649 err = decoder.Decoder.Skip() 17650 if err != nil { 17651 return err 17652 } 17653 17654 } 17655 decoder = originalDecoder 17656 } 17657 *v = sv 17658 return nil 17659} 17660 17661func awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(v **types.NoSuchQueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 17662 if v == nil { 17663 return fmt.Errorf("unexpected nil of type %T", v) 17664 } 17665 var sv *types.NoSuchQueryLoggingConfig 17666 if *v == nil { 17667 sv = &types.NoSuchQueryLoggingConfig{} 17668 } else { 17669 sv = *v 17670 } 17671 17672 for { 17673 t, done, err := decoder.Token() 17674 if err != nil { 17675 return err 17676 } 17677 if done { 17678 break 17679 } 17680 originalDecoder := decoder 17681 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17682 switch { 17683 case strings.EqualFold("message", t.Name.Local): 17684 val, err := decoder.Value() 17685 if err != nil { 17686 return err 17687 } 17688 if val == nil { 17689 break 17690 } 17691 { 17692 xtv := string(val) 17693 sv.Message = ptr.String(xtv) 17694 } 17695 17696 default: 17697 // Do nothing and ignore the unexpected tag element 17698 err = decoder.Decoder.Skip() 17699 if err != nil { 17700 return err 17701 } 17702 17703 } 17704 decoder = originalDecoder 17705 } 17706 *v = sv 17707 return nil 17708} 17709 17710func awsRestxml_deserializeDocumentNoSuchTrafficPolicy(v **types.NoSuchTrafficPolicy, decoder smithyxml.NodeDecoder) error { 17711 if v == nil { 17712 return fmt.Errorf("unexpected nil of type %T", v) 17713 } 17714 var sv *types.NoSuchTrafficPolicy 17715 if *v == nil { 17716 sv = &types.NoSuchTrafficPolicy{} 17717 } else { 17718 sv = *v 17719 } 17720 17721 for { 17722 t, done, err := decoder.Token() 17723 if err != nil { 17724 return err 17725 } 17726 if done { 17727 break 17728 } 17729 originalDecoder := decoder 17730 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17731 switch { 17732 case strings.EqualFold("message", t.Name.Local): 17733 val, err := decoder.Value() 17734 if err != nil { 17735 return err 17736 } 17737 if val == nil { 17738 break 17739 } 17740 { 17741 xtv := string(val) 17742 sv.Message = ptr.String(xtv) 17743 } 17744 17745 default: 17746 // Do nothing and ignore the unexpected tag element 17747 err = decoder.Decoder.Skip() 17748 if err != nil { 17749 return err 17750 } 17751 17752 } 17753 decoder = originalDecoder 17754 } 17755 *v = sv 17756 return nil 17757} 17758 17759func awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(v **types.NoSuchTrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 17760 if v == nil { 17761 return fmt.Errorf("unexpected nil of type %T", v) 17762 } 17763 var sv *types.NoSuchTrafficPolicyInstance 17764 if *v == nil { 17765 sv = &types.NoSuchTrafficPolicyInstance{} 17766 } else { 17767 sv = *v 17768 } 17769 17770 for { 17771 t, done, err := decoder.Token() 17772 if err != nil { 17773 return err 17774 } 17775 if done { 17776 break 17777 } 17778 originalDecoder := decoder 17779 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17780 switch { 17781 case strings.EqualFold("message", t.Name.Local): 17782 val, err := decoder.Value() 17783 if err != nil { 17784 return err 17785 } 17786 if val == nil { 17787 break 17788 } 17789 { 17790 xtv := string(val) 17791 sv.Message = ptr.String(xtv) 17792 } 17793 17794 default: 17795 // Do nothing and ignore the unexpected tag element 17796 err = decoder.Decoder.Skip() 17797 if err != nil { 17798 return err 17799 } 17800 17801 } 17802 decoder = originalDecoder 17803 } 17804 *v = sv 17805 return nil 17806} 17807 17808func awsRestxml_deserializeDocumentNotAuthorizedException(v **types.NotAuthorizedException, decoder smithyxml.NodeDecoder) error { 17809 if v == nil { 17810 return fmt.Errorf("unexpected nil of type %T", v) 17811 } 17812 var sv *types.NotAuthorizedException 17813 if *v == nil { 17814 sv = &types.NotAuthorizedException{} 17815 } else { 17816 sv = *v 17817 } 17818 17819 for { 17820 t, done, err := decoder.Token() 17821 if err != nil { 17822 return err 17823 } 17824 if done { 17825 break 17826 } 17827 originalDecoder := decoder 17828 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17829 switch { 17830 case strings.EqualFold("message", t.Name.Local): 17831 val, err := decoder.Value() 17832 if err != nil { 17833 return err 17834 } 17835 if val == nil { 17836 break 17837 } 17838 { 17839 xtv := string(val) 17840 sv.Message = ptr.String(xtv) 17841 } 17842 17843 default: 17844 // Do nothing and ignore the unexpected tag element 17845 err = decoder.Decoder.Skip() 17846 if err != nil { 17847 return err 17848 } 17849 17850 } 17851 decoder = originalDecoder 17852 } 17853 *v = sv 17854 return nil 17855} 17856 17857func awsRestxml_deserializeDocumentPriorRequestNotComplete(v **types.PriorRequestNotComplete, decoder smithyxml.NodeDecoder) error { 17858 if v == nil { 17859 return fmt.Errorf("unexpected nil of type %T", v) 17860 } 17861 var sv *types.PriorRequestNotComplete 17862 if *v == nil { 17863 sv = &types.PriorRequestNotComplete{} 17864 } else { 17865 sv = *v 17866 } 17867 17868 for { 17869 t, done, err := decoder.Token() 17870 if err != nil { 17871 return err 17872 } 17873 if done { 17874 break 17875 } 17876 originalDecoder := decoder 17877 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17878 switch { 17879 case strings.EqualFold("message", t.Name.Local): 17880 val, err := decoder.Value() 17881 if err != nil { 17882 return err 17883 } 17884 if val == nil { 17885 break 17886 } 17887 { 17888 xtv := string(val) 17889 sv.Message = ptr.String(xtv) 17890 } 17891 17892 default: 17893 // Do nothing and ignore the unexpected tag element 17894 err = decoder.Decoder.Skip() 17895 if err != nil { 17896 return err 17897 } 17898 17899 } 17900 decoder = originalDecoder 17901 } 17902 *v = sv 17903 return nil 17904} 17905 17906func awsRestxml_deserializeDocumentPublicZoneVPCAssociation(v **types.PublicZoneVPCAssociation, decoder smithyxml.NodeDecoder) error { 17907 if v == nil { 17908 return fmt.Errorf("unexpected nil of type %T", v) 17909 } 17910 var sv *types.PublicZoneVPCAssociation 17911 if *v == nil { 17912 sv = &types.PublicZoneVPCAssociation{} 17913 } else { 17914 sv = *v 17915 } 17916 17917 for { 17918 t, done, err := decoder.Token() 17919 if err != nil { 17920 return err 17921 } 17922 if done { 17923 break 17924 } 17925 originalDecoder := decoder 17926 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17927 switch { 17928 case strings.EqualFold("message", t.Name.Local): 17929 val, err := decoder.Value() 17930 if err != nil { 17931 return err 17932 } 17933 if val == nil { 17934 break 17935 } 17936 { 17937 xtv := string(val) 17938 sv.Message = ptr.String(xtv) 17939 } 17940 17941 default: 17942 // Do nothing and ignore the unexpected tag element 17943 err = decoder.Decoder.Skip() 17944 if err != nil { 17945 return err 17946 } 17947 17948 } 17949 decoder = originalDecoder 17950 } 17951 *v = sv 17952 return nil 17953} 17954 17955func awsRestxml_deserializeDocumentQueryLoggingConfig(v **types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 17956 if v == nil { 17957 return fmt.Errorf("unexpected nil of type %T", v) 17958 } 17959 var sv *types.QueryLoggingConfig 17960 if *v == nil { 17961 sv = &types.QueryLoggingConfig{} 17962 } else { 17963 sv = *v 17964 } 17965 17966 for { 17967 t, done, err := decoder.Token() 17968 if err != nil { 17969 return err 17970 } 17971 if done { 17972 break 17973 } 17974 originalDecoder := decoder 17975 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17976 switch { 17977 case strings.EqualFold("CloudWatchLogsLogGroupArn", t.Name.Local): 17978 val, err := decoder.Value() 17979 if err != nil { 17980 return err 17981 } 17982 if val == nil { 17983 break 17984 } 17985 { 17986 xtv := string(val) 17987 sv.CloudWatchLogsLogGroupArn = ptr.String(xtv) 17988 } 17989 17990 case strings.EqualFold("HostedZoneId", t.Name.Local): 17991 val, err := decoder.Value() 17992 if err != nil { 17993 return err 17994 } 17995 if val == nil { 17996 break 17997 } 17998 { 17999 xtv := string(val) 18000 sv.HostedZoneId = ptr.String(xtv) 18001 } 18002 18003 case strings.EqualFold("Id", t.Name.Local): 18004 val, err := decoder.Value() 18005 if err != nil { 18006 return err 18007 } 18008 if val == nil { 18009 break 18010 } 18011 { 18012 xtv := string(val) 18013 sv.Id = ptr.String(xtv) 18014 } 18015 18016 default: 18017 // Do nothing and ignore the unexpected tag element 18018 err = decoder.Decoder.Skip() 18019 if err != nil { 18020 return err 18021 } 18022 18023 } 18024 decoder = originalDecoder 18025 } 18026 *v = sv 18027 return nil 18028} 18029 18030func awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(v **types.QueryLoggingConfigAlreadyExists, decoder smithyxml.NodeDecoder) error { 18031 if v == nil { 18032 return fmt.Errorf("unexpected nil of type %T", v) 18033 } 18034 var sv *types.QueryLoggingConfigAlreadyExists 18035 if *v == nil { 18036 sv = &types.QueryLoggingConfigAlreadyExists{} 18037 } else { 18038 sv = *v 18039 } 18040 18041 for { 18042 t, done, err := decoder.Token() 18043 if err != nil { 18044 return err 18045 } 18046 if done { 18047 break 18048 } 18049 originalDecoder := decoder 18050 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18051 switch { 18052 case strings.EqualFold("message", t.Name.Local): 18053 val, err := decoder.Value() 18054 if err != nil { 18055 return err 18056 } 18057 if val == nil { 18058 break 18059 } 18060 { 18061 xtv := string(val) 18062 sv.Message = ptr.String(xtv) 18063 } 18064 18065 default: 18066 // Do nothing and ignore the unexpected tag element 18067 err = decoder.Decoder.Skip() 18068 if err != nil { 18069 return err 18070 } 18071 18072 } 18073 decoder = originalDecoder 18074 } 18075 *v = sv 18076 return nil 18077} 18078 18079func awsRestxml_deserializeDocumentQueryLoggingConfigs(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 18080 if v == nil { 18081 return fmt.Errorf("unexpected nil of type %T", v) 18082 } 18083 var sv []types.QueryLoggingConfig 18084 if *v == nil { 18085 sv = make([]types.QueryLoggingConfig, 0) 18086 } else { 18087 sv = *v 18088 } 18089 18090 originalDecoder := decoder 18091 for { 18092 t, done, err := decoder.Token() 18093 if err != nil { 18094 return err 18095 } 18096 if done { 18097 break 18098 } 18099 switch { 18100 case strings.EqualFold("QueryLoggingConfig", t.Name.Local): 18101 var col types.QueryLoggingConfig 18102 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18103 destAddr := &col 18104 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil { 18105 return err 18106 } 18107 col = *destAddr 18108 sv = append(sv, col) 18109 18110 default: 18111 err = decoder.Decoder.Skip() 18112 if err != nil { 18113 return err 18114 } 18115 18116 } 18117 decoder = originalDecoder 18118 } 18119 *v = sv 18120 return nil 18121} 18122 18123func awsRestxml_deserializeDocumentQueryLoggingConfigsUnwrapped(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 18124 var sv []types.QueryLoggingConfig 18125 if *v == nil { 18126 sv = make([]types.QueryLoggingConfig, 0) 18127 } else { 18128 sv = *v 18129 } 18130 18131 switch { 18132 default: 18133 var mv types.QueryLoggingConfig 18134 t := decoder.StartEl 18135 _ = t 18136 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18137 destAddr := &mv 18138 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil { 18139 return err 18140 } 18141 mv = *destAddr 18142 sv = append(sv, mv) 18143 } 18144 *v = sv 18145 return nil 18146} 18147func awsRestxml_deserializeDocumentRecordData(v *[]string, decoder smithyxml.NodeDecoder) error { 18148 if v == nil { 18149 return fmt.Errorf("unexpected nil of type %T", v) 18150 } 18151 var sv []string 18152 if *v == nil { 18153 sv = make([]string, 0) 18154 } else { 18155 sv = *v 18156 } 18157 18158 originalDecoder := decoder 18159 for { 18160 t, done, err := decoder.Token() 18161 if err != nil { 18162 return err 18163 } 18164 if done { 18165 break 18166 } 18167 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18168 decoder = memberDecoder 18169 switch { 18170 case strings.EqualFold("RecordDataEntry", t.Name.Local): 18171 var col string 18172 val, err := decoder.Value() 18173 if err != nil { 18174 return err 18175 } 18176 if val == nil { 18177 break 18178 } 18179 { 18180 xtv := string(val) 18181 col = xtv 18182 } 18183 sv = append(sv, col) 18184 18185 default: 18186 err = decoder.Decoder.Skip() 18187 if err != nil { 18188 return err 18189 } 18190 18191 } 18192 decoder = originalDecoder 18193 } 18194 *v = sv 18195 return nil 18196} 18197 18198func awsRestxml_deserializeDocumentRecordDataUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 18199 var sv []string 18200 if *v == nil { 18201 sv = make([]string, 0) 18202 } else { 18203 sv = *v 18204 } 18205 18206 switch { 18207 default: 18208 var mv string 18209 t := decoder.StartEl 18210 _ = t 18211 val, err := decoder.Value() 18212 if err != nil { 18213 return err 18214 } 18215 if val == nil { 18216 break 18217 } 18218 { 18219 xtv := string(val) 18220 mv = xtv 18221 } 18222 sv = append(sv, mv) 18223 } 18224 *v = sv 18225 return nil 18226} 18227func awsRestxml_deserializeDocumentResourceRecord(v **types.ResourceRecord, decoder smithyxml.NodeDecoder) error { 18228 if v == nil { 18229 return fmt.Errorf("unexpected nil of type %T", v) 18230 } 18231 var sv *types.ResourceRecord 18232 if *v == nil { 18233 sv = &types.ResourceRecord{} 18234 } else { 18235 sv = *v 18236 } 18237 18238 for { 18239 t, done, err := decoder.Token() 18240 if err != nil { 18241 return err 18242 } 18243 if done { 18244 break 18245 } 18246 originalDecoder := decoder 18247 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18248 switch { 18249 case strings.EqualFold("Value", t.Name.Local): 18250 val, err := decoder.Value() 18251 if err != nil { 18252 return err 18253 } 18254 if val == nil { 18255 break 18256 } 18257 { 18258 xtv := string(val) 18259 sv.Value = ptr.String(xtv) 18260 } 18261 18262 default: 18263 // Do nothing and ignore the unexpected tag element 18264 err = decoder.Decoder.Skip() 18265 if err != nil { 18266 return err 18267 } 18268 18269 } 18270 decoder = originalDecoder 18271 } 18272 *v = sv 18273 return nil 18274} 18275 18276func awsRestxml_deserializeDocumentResourceRecords(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error { 18277 if v == nil { 18278 return fmt.Errorf("unexpected nil of type %T", v) 18279 } 18280 var sv []types.ResourceRecord 18281 if *v == nil { 18282 sv = make([]types.ResourceRecord, 0) 18283 } else { 18284 sv = *v 18285 } 18286 18287 originalDecoder := decoder 18288 for { 18289 t, done, err := decoder.Token() 18290 if err != nil { 18291 return err 18292 } 18293 if done { 18294 break 18295 } 18296 switch { 18297 case strings.EqualFold("ResourceRecord", t.Name.Local): 18298 var col types.ResourceRecord 18299 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18300 destAddr := &col 18301 if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil { 18302 return err 18303 } 18304 col = *destAddr 18305 sv = append(sv, col) 18306 18307 default: 18308 err = decoder.Decoder.Skip() 18309 if err != nil { 18310 return err 18311 } 18312 18313 } 18314 decoder = originalDecoder 18315 } 18316 *v = sv 18317 return nil 18318} 18319 18320func awsRestxml_deserializeDocumentResourceRecordsUnwrapped(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error { 18321 var sv []types.ResourceRecord 18322 if *v == nil { 18323 sv = make([]types.ResourceRecord, 0) 18324 } else { 18325 sv = *v 18326 } 18327 18328 switch { 18329 default: 18330 var mv types.ResourceRecord 18331 t := decoder.StartEl 18332 _ = t 18333 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18334 destAddr := &mv 18335 if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil { 18336 return err 18337 } 18338 mv = *destAddr 18339 sv = append(sv, mv) 18340 } 18341 *v = sv 18342 return nil 18343} 18344func awsRestxml_deserializeDocumentResourceRecordSet(v **types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error { 18345 if v == nil { 18346 return fmt.Errorf("unexpected nil of type %T", v) 18347 } 18348 var sv *types.ResourceRecordSet 18349 if *v == nil { 18350 sv = &types.ResourceRecordSet{} 18351 } else { 18352 sv = *v 18353 } 18354 18355 for { 18356 t, done, err := decoder.Token() 18357 if err != nil { 18358 return err 18359 } 18360 if done { 18361 break 18362 } 18363 originalDecoder := decoder 18364 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18365 switch { 18366 case strings.EqualFold("AliasTarget", t.Name.Local): 18367 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18368 if err := awsRestxml_deserializeDocumentAliasTarget(&sv.AliasTarget, nodeDecoder); err != nil { 18369 return err 18370 } 18371 18372 case strings.EqualFold("Failover", t.Name.Local): 18373 val, err := decoder.Value() 18374 if err != nil { 18375 return err 18376 } 18377 if val == nil { 18378 break 18379 } 18380 { 18381 xtv := string(val) 18382 sv.Failover = types.ResourceRecordSetFailover(xtv) 18383 } 18384 18385 case strings.EqualFold("GeoLocation", t.Name.Local): 18386 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18387 if err := awsRestxml_deserializeDocumentGeoLocation(&sv.GeoLocation, nodeDecoder); err != nil { 18388 return err 18389 } 18390 18391 case strings.EqualFold("HealthCheckId", t.Name.Local): 18392 val, err := decoder.Value() 18393 if err != nil { 18394 return err 18395 } 18396 if val == nil { 18397 break 18398 } 18399 { 18400 xtv := string(val) 18401 sv.HealthCheckId = ptr.String(xtv) 18402 } 18403 18404 case strings.EqualFold("MultiValueAnswer", t.Name.Local): 18405 val, err := decoder.Value() 18406 if err != nil { 18407 return err 18408 } 18409 if val == nil { 18410 break 18411 } 18412 { 18413 xtv, err := strconv.ParseBool(string(val)) 18414 if err != nil { 18415 return fmt.Errorf("expected ResourceRecordSetMultiValueAnswer to be of type *bool, got %T instead", val) 18416 } 18417 sv.MultiValueAnswer = ptr.Bool(xtv) 18418 } 18419 18420 case strings.EqualFold("Name", t.Name.Local): 18421 val, err := decoder.Value() 18422 if err != nil { 18423 return err 18424 } 18425 if val == nil { 18426 break 18427 } 18428 { 18429 xtv := string(val) 18430 sv.Name = ptr.String(xtv) 18431 } 18432 18433 case strings.EqualFold("Region", t.Name.Local): 18434 val, err := decoder.Value() 18435 if err != nil { 18436 return err 18437 } 18438 if val == nil { 18439 break 18440 } 18441 { 18442 xtv := string(val) 18443 sv.Region = types.ResourceRecordSetRegion(xtv) 18444 } 18445 18446 case strings.EqualFold("ResourceRecords", t.Name.Local): 18447 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18448 if err := awsRestxml_deserializeDocumentResourceRecords(&sv.ResourceRecords, nodeDecoder); err != nil { 18449 return err 18450 } 18451 18452 case strings.EqualFold("SetIdentifier", t.Name.Local): 18453 val, err := decoder.Value() 18454 if err != nil { 18455 return err 18456 } 18457 if val == nil { 18458 break 18459 } 18460 { 18461 xtv := string(val) 18462 sv.SetIdentifier = ptr.String(xtv) 18463 } 18464 18465 case strings.EqualFold("TrafficPolicyInstanceId", t.Name.Local): 18466 val, err := decoder.Value() 18467 if err != nil { 18468 return err 18469 } 18470 if val == nil { 18471 break 18472 } 18473 { 18474 xtv := string(val) 18475 sv.TrafficPolicyInstanceId = ptr.String(xtv) 18476 } 18477 18478 case strings.EqualFold("TTL", t.Name.Local): 18479 val, err := decoder.Value() 18480 if err != nil { 18481 return err 18482 } 18483 if val == nil { 18484 break 18485 } 18486 { 18487 xtv := string(val) 18488 i64, err := strconv.ParseInt(xtv, 10, 64) 18489 if err != nil { 18490 return err 18491 } 18492 sv.TTL = ptr.Int64(i64) 18493 } 18494 18495 case strings.EqualFold("Type", t.Name.Local): 18496 val, err := decoder.Value() 18497 if err != nil { 18498 return err 18499 } 18500 if val == nil { 18501 break 18502 } 18503 { 18504 xtv := string(val) 18505 sv.Type = types.RRType(xtv) 18506 } 18507 18508 case strings.EqualFold("Weight", t.Name.Local): 18509 val, err := decoder.Value() 18510 if err != nil { 18511 return err 18512 } 18513 if val == nil { 18514 break 18515 } 18516 { 18517 xtv := string(val) 18518 i64, err := strconv.ParseInt(xtv, 10, 64) 18519 if err != nil { 18520 return err 18521 } 18522 sv.Weight = ptr.Int64(i64) 18523 } 18524 18525 default: 18526 // Do nothing and ignore the unexpected tag element 18527 err = decoder.Decoder.Skip() 18528 if err != nil { 18529 return err 18530 } 18531 18532 } 18533 decoder = originalDecoder 18534 } 18535 *v = sv 18536 return nil 18537} 18538 18539func awsRestxml_deserializeDocumentResourceRecordSets(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error { 18540 if v == nil { 18541 return fmt.Errorf("unexpected nil of type %T", v) 18542 } 18543 var sv []types.ResourceRecordSet 18544 if *v == nil { 18545 sv = make([]types.ResourceRecordSet, 0) 18546 } else { 18547 sv = *v 18548 } 18549 18550 originalDecoder := decoder 18551 for { 18552 t, done, err := decoder.Token() 18553 if err != nil { 18554 return err 18555 } 18556 if done { 18557 break 18558 } 18559 switch { 18560 case strings.EqualFold("ResourceRecordSet", t.Name.Local): 18561 var col types.ResourceRecordSet 18562 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18563 destAddr := &col 18564 if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil { 18565 return err 18566 } 18567 col = *destAddr 18568 sv = append(sv, col) 18569 18570 default: 18571 err = decoder.Decoder.Skip() 18572 if err != nil { 18573 return err 18574 } 18575 18576 } 18577 decoder = originalDecoder 18578 } 18579 *v = sv 18580 return nil 18581} 18582 18583func awsRestxml_deserializeDocumentResourceRecordSetsUnwrapped(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error { 18584 var sv []types.ResourceRecordSet 18585 if *v == nil { 18586 sv = make([]types.ResourceRecordSet, 0) 18587 } else { 18588 sv = *v 18589 } 18590 18591 switch { 18592 default: 18593 var mv types.ResourceRecordSet 18594 t := decoder.StartEl 18595 _ = t 18596 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18597 destAddr := &mv 18598 if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil { 18599 return err 18600 } 18601 mv = *destAddr 18602 sv = append(sv, mv) 18603 } 18604 *v = sv 18605 return nil 18606} 18607func awsRestxml_deserializeDocumentResourceTagSet(v **types.ResourceTagSet, decoder smithyxml.NodeDecoder) error { 18608 if v == nil { 18609 return fmt.Errorf("unexpected nil of type %T", v) 18610 } 18611 var sv *types.ResourceTagSet 18612 if *v == nil { 18613 sv = &types.ResourceTagSet{} 18614 } else { 18615 sv = *v 18616 } 18617 18618 for { 18619 t, done, err := decoder.Token() 18620 if err != nil { 18621 return err 18622 } 18623 if done { 18624 break 18625 } 18626 originalDecoder := decoder 18627 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18628 switch { 18629 case strings.EqualFold("ResourceId", t.Name.Local): 18630 val, err := decoder.Value() 18631 if err != nil { 18632 return err 18633 } 18634 if val == nil { 18635 break 18636 } 18637 { 18638 xtv := string(val) 18639 sv.ResourceId = ptr.String(xtv) 18640 } 18641 18642 case strings.EqualFold("ResourceType", t.Name.Local): 18643 val, err := decoder.Value() 18644 if err != nil { 18645 return err 18646 } 18647 if val == nil { 18648 break 18649 } 18650 { 18651 xtv := string(val) 18652 sv.ResourceType = types.TagResourceType(xtv) 18653 } 18654 18655 case strings.EqualFold("Tags", t.Name.Local): 18656 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18657 if err := awsRestxml_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil { 18658 return err 18659 } 18660 18661 default: 18662 // Do nothing and ignore the unexpected tag element 18663 err = decoder.Decoder.Skip() 18664 if err != nil { 18665 return err 18666 } 18667 18668 } 18669 decoder = originalDecoder 18670 } 18671 *v = sv 18672 return nil 18673} 18674 18675func awsRestxml_deserializeDocumentResourceTagSetList(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error { 18676 if v == nil { 18677 return fmt.Errorf("unexpected nil of type %T", v) 18678 } 18679 var sv []types.ResourceTagSet 18680 if *v == nil { 18681 sv = make([]types.ResourceTagSet, 0) 18682 } else { 18683 sv = *v 18684 } 18685 18686 originalDecoder := decoder 18687 for { 18688 t, done, err := decoder.Token() 18689 if err != nil { 18690 return err 18691 } 18692 if done { 18693 break 18694 } 18695 switch { 18696 case strings.EqualFold("ResourceTagSet", t.Name.Local): 18697 var col types.ResourceTagSet 18698 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18699 destAddr := &col 18700 if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil { 18701 return err 18702 } 18703 col = *destAddr 18704 sv = append(sv, col) 18705 18706 default: 18707 err = decoder.Decoder.Skip() 18708 if err != nil { 18709 return err 18710 } 18711 18712 } 18713 decoder = originalDecoder 18714 } 18715 *v = sv 18716 return nil 18717} 18718 18719func awsRestxml_deserializeDocumentResourceTagSetListUnwrapped(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error { 18720 var sv []types.ResourceTagSet 18721 if *v == nil { 18722 sv = make([]types.ResourceTagSet, 0) 18723 } else { 18724 sv = *v 18725 } 18726 18727 switch { 18728 default: 18729 var mv types.ResourceTagSet 18730 t := decoder.StartEl 18731 _ = t 18732 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18733 destAddr := &mv 18734 if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil { 18735 return err 18736 } 18737 mv = *destAddr 18738 sv = append(sv, mv) 18739 } 18740 *v = sv 18741 return nil 18742} 18743func awsRestxml_deserializeDocumentReusableDelegationSetLimit(v **types.ReusableDelegationSetLimit, decoder smithyxml.NodeDecoder) error { 18744 if v == nil { 18745 return fmt.Errorf("unexpected nil of type %T", v) 18746 } 18747 var sv *types.ReusableDelegationSetLimit 18748 if *v == nil { 18749 sv = &types.ReusableDelegationSetLimit{} 18750 } else { 18751 sv = *v 18752 } 18753 18754 for { 18755 t, done, err := decoder.Token() 18756 if err != nil { 18757 return err 18758 } 18759 if done { 18760 break 18761 } 18762 originalDecoder := decoder 18763 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18764 switch { 18765 case strings.EqualFold("Type", t.Name.Local): 18766 val, err := decoder.Value() 18767 if err != nil { 18768 return err 18769 } 18770 if val == nil { 18771 break 18772 } 18773 { 18774 xtv := string(val) 18775 sv.Type = types.ReusableDelegationSetLimitType(xtv) 18776 } 18777 18778 case strings.EqualFold("Value", t.Name.Local): 18779 val, err := decoder.Value() 18780 if err != nil { 18781 return err 18782 } 18783 if val == nil { 18784 break 18785 } 18786 { 18787 xtv := string(val) 18788 i64, err := strconv.ParseInt(xtv, 10, 64) 18789 if err != nil { 18790 return err 18791 } 18792 sv.Value = i64 18793 } 18794 18795 default: 18796 // Do nothing and ignore the unexpected tag element 18797 err = decoder.Decoder.Skip() 18798 if err != nil { 18799 return err 18800 } 18801 18802 } 18803 decoder = originalDecoder 18804 } 18805 *v = sv 18806 return nil 18807} 18808 18809func awsRestxml_deserializeDocumentStatusReport(v **types.StatusReport, decoder smithyxml.NodeDecoder) error { 18810 if v == nil { 18811 return fmt.Errorf("unexpected nil of type %T", v) 18812 } 18813 var sv *types.StatusReport 18814 if *v == nil { 18815 sv = &types.StatusReport{} 18816 } else { 18817 sv = *v 18818 } 18819 18820 for { 18821 t, done, err := decoder.Token() 18822 if err != nil { 18823 return err 18824 } 18825 if done { 18826 break 18827 } 18828 originalDecoder := decoder 18829 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18830 switch { 18831 case strings.EqualFold("CheckedTime", t.Name.Local): 18832 val, err := decoder.Value() 18833 if err != nil { 18834 return err 18835 } 18836 if val == nil { 18837 break 18838 } 18839 { 18840 xtv := string(val) 18841 t, err := smithytime.ParseDateTime(xtv) 18842 if err != nil { 18843 return err 18844 } 18845 sv.CheckedTime = ptr.Time(t) 18846 } 18847 18848 case strings.EqualFold("Status", t.Name.Local): 18849 val, err := decoder.Value() 18850 if err != nil { 18851 return err 18852 } 18853 if val == nil { 18854 break 18855 } 18856 { 18857 xtv := string(val) 18858 sv.Status = ptr.String(xtv) 18859 } 18860 18861 default: 18862 // Do nothing and ignore the unexpected tag element 18863 err = decoder.Decoder.Skip() 18864 if err != nil { 18865 return err 18866 } 18867 18868 } 18869 decoder = originalDecoder 18870 } 18871 *v = sv 18872 return nil 18873} 18874 18875func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error { 18876 if v == nil { 18877 return fmt.Errorf("unexpected nil of type %T", v) 18878 } 18879 var sv *types.Tag 18880 if *v == nil { 18881 sv = &types.Tag{} 18882 } else { 18883 sv = *v 18884 } 18885 18886 for { 18887 t, done, err := decoder.Token() 18888 if err != nil { 18889 return err 18890 } 18891 if done { 18892 break 18893 } 18894 originalDecoder := decoder 18895 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18896 switch { 18897 case strings.EqualFold("Key", t.Name.Local): 18898 val, err := decoder.Value() 18899 if err != nil { 18900 return err 18901 } 18902 if val == nil { 18903 break 18904 } 18905 { 18906 xtv := string(val) 18907 sv.Key = ptr.String(xtv) 18908 } 18909 18910 case strings.EqualFold("Value", t.Name.Local): 18911 val, err := decoder.Value() 18912 if err != nil { 18913 return err 18914 } 18915 if val == nil { 18916 break 18917 } 18918 { 18919 xtv := string(val) 18920 sv.Value = ptr.String(xtv) 18921 } 18922 18923 default: 18924 // Do nothing and ignore the unexpected tag element 18925 err = decoder.Decoder.Skip() 18926 if err != nil { 18927 return err 18928 } 18929 18930 } 18931 decoder = originalDecoder 18932 } 18933 *v = sv 18934 return nil 18935} 18936 18937func awsRestxml_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 18938 if v == nil { 18939 return fmt.Errorf("unexpected nil of type %T", v) 18940 } 18941 var sv []types.Tag 18942 if *v == nil { 18943 sv = make([]types.Tag, 0) 18944 } else { 18945 sv = *v 18946 } 18947 18948 originalDecoder := decoder 18949 for { 18950 t, done, err := decoder.Token() 18951 if err != nil { 18952 return err 18953 } 18954 if done { 18955 break 18956 } 18957 switch { 18958 case strings.EqualFold("Tag", t.Name.Local): 18959 var col types.Tag 18960 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18961 destAddr := &col 18962 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 18963 return err 18964 } 18965 col = *destAddr 18966 sv = append(sv, col) 18967 18968 default: 18969 err = decoder.Decoder.Skip() 18970 if err != nil { 18971 return err 18972 } 18973 18974 } 18975 decoder = originalDecoder 18976 } 18977 *v = sv 18978 return nil 18979} 18980 18981func awsRestxml_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 18982 var sv []types.Tag 18983 if *v == nil { 18984 sv = make([]types.Tag, 0) 18985 } else { 18986 sv = *v 18987 } 18988 18989 switch { 18990 default: 18991 var mv types.Tag 18992 t := decoder.StartEl 18993 _ = t 18994 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18995 destAddr := &mv 18996 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 18997 return err 18998 } 18999 mv = *destAddr 19000 sv = append(sv, mv) 19001 } 19002 *v = sv 19003 return nil 19004} 19005func awsRestxml_deserializeDocumentThrottlingException(v **types.ThrottlingException, decoder smithyxml.NodeDecoder) error { 19006 if v == nil { 19007 return fmt.Errorf("unexpected nil of type %T", v) 19008 } 19009 var sv *types.ThrottlingException 19010 if *v == nil { 19011 sv = &types.ThrottlingException{} 19012 } else { 19013 sv = *v 19014 } 19015 19016 for { 19017 t, done, err := decoder.Token() 19018 if err != nil { 19019 return err 19020 } 19021 if done { 19022 break 19023 } 19024 originalDecoder := decoder 19025 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19026 switch { 19027 case strings.EqualFold("message", t.Name.Local): 19028 val, err := decoder.Value() 19029 if err != nil { 19030 return err 19031 } 19032 if val == nil { 19033 break 19034 } 19035 { 19036 xtv := string(val) 19037 sv.Message = ptr.String(xtv) 19038 } 19039 19040 default: 19041 // Do nothing and ignore the unexpected tag element 19042 err = decoder.Decoder.Skip() 19043 if err != nil { 19044 return err 19045 } 19046 19047 } 19048 decoder = originalDecoder 19049 } 19050 *v = sv 19051 return nil 19052} 19053 19054func awsRestxml_deserializeDocumentTooManyHealthChecks(v **types.TooManyHealthChecks, decoder smithyxml.NodeDecoder) error { 19055 if v == nil { 19056 return fmt.Errorf("unexpected nil of type %T", v) 19057 } 19058 var sv *types.TooManyHealthChecks 19059 if *v == nil { 19060 sv = &types.TooManyHealthChecks{} 19061 } else { 19062 sv = *v 19063 } 19064 19065 for { 19066 t, done, err := decoder.Token() 19067 if err != nil { 19068 return err 19069 } 19070 if done { 19071 break 19072 } 19073 originalDecoder := decoder 19074 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19075 switch { 19076 case strings.EqualFold("message", t.Name.Local): 19077 val, err := decoder.Value() 19078 if err != nil { 19079 return err 19080 } 19081 if val == nil { 19082 break 19083 } 19084 { 19085 xtv := string(val) 19086 sv.Message = ptr.String(xtv) 19087 } 19088 19089 default: 19090 // Do nothing and ignore the unexpected tag element 19091 err = decoder.Decoder.Skip() 19092 if err != nil { 19093 return err 19094 } 19095 19096 } 19097 decoder = originalDecoder 19098 } 19099 *v = sv 19100 return nil 19101} 19102 19103func awsRestxml_deserializeDocumentTooManyHostedZones(v **types.TooManyHostedZones, decoder smithyxml.NodeDecoder) error { 19104 if v == nil { 19105 return fmt.Errorf("unexpected nil of type %T", v) 19106 } 19107 var sv *types.TooManyHostedZones 19108 if *v == nil { 19109 sv = &types.TooManyHostedZones{} 19110 } else { 19111 sv = *v 19112 } 19113 19114 for { 19115 t, done, err := decoder.Token() 19116 if err != nil { 19117 return err 19118 } 19119 if done { 19120 break 19121 } 19122 originalDecoder := decoder 19123 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19124 switch { 19125 case strings.EqualFold("message", t.Name.Local): 19126 val, err := decoder.Value() 19127 if err != nil { 19128 return err 19129 } 19130 if val == nil { 19131 break 19132 } 19133 { 19134 xtv := string(val) 19135 sv.Message = ptr.String(xtv) 19136 } 19137 19138 default: 19139 // Do nothing and ignore the unexpected tag element 19140 err = decoder.Decoder.Skip() 19141 if err != nil { 19142 return err 19143 } 19144 19145 } 19146 decoder = originalDecoder 19147 } 19148 *v = sv 19149 return nil 19150} 19151 19152func awsRestxml_deserializeDocumentTooManyKeySigningKeys(v **types.TooManyKeySigningKeys, decoder smithyxml.NodeDecoder) error { 19153 if v == nil { 19154 return fmt.Errorf("unexpected nil of type %T", v) 19155 } 19156 var sv *types.TooManyKeySigningKeys 19157 if *v == nil { 19158 sv = &types.TooManyKeySigningKeys{} 19159 } else { 19160 sv = *v 19161 } 19162 19163 for { 19164 t, done, err := decoder.Token() 19165 if err != nil { 19166 return err 19167 } 19168 if done { 19169 break 19170 } 19171 originalDecoder := decoder 19172 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19173 switch { 19174 case strings.EqualFold("message", t.Name.Local): 19175 val, err := decoder.Value() 19176 if err != nil { 19177 return err 19178 } 19179 if val == nil { 19180 break 19181 } 19182 { 19183 xtv := string(val) 19184 sv.Message = ptr.String(xtv) 19185 } 19186 19187 default: 19188 // Do nothing and ignore the unexpected tag element 19189 err = decoder.Decoder.Skip() 19190 if err != nil { 19191 return err 19192 } 19193 19194 } 19195 decoder = originalDecoder 19196 } 19197 *v = sv 19198 return nil 19199} 19200 19201func awsRestxml_deserializeDocumentTooManyTrafficPolicies(v **types.TooManyTrafficPolicies, decoder smithyxml.NodeDecoder) error { 19202 if v == nil { 19203 return fmt.Errorf("unexpected nil of type %T", v) 19204 } 19205 var sv *types.TooManyTrafficPolicies 19206 if *v == nil { 19207 sv = &types.TooManyTrafficPolicies{} 19208 } else { 19209 sv = *v 19210 } 19211 19212 for { 19213 t, done, err := decoder.Token() 19214 if err != nil { 19215 return err 19216 } 19217 if done { 19218 break 19219 } 19220 originalDecoder := decoder 19221 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19222 switch { 19223 case strings.EqualFold("message", t.Name.Local): 19224 val, err := decoder.Value() 19225 if err != nil { 19226 return err 19227 } 19228 if val == nil { 19229 break 19230 } 19231 { 19232 xtv := string(val) 19233 sv.Message = ptr.String(xtv) 19234 } 19235 19236 default: 19237 // Do nothing and ignore the unexpected tag element 19238 err = decoder.Decoder.Skip() 19239 if err != nil { 19240 return err 19241 } 19242 19243 } 19244 decoder = originalDecoder 19245 } 19246 *v = sv 19247 return nil 19248} 19249 19250func awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(v **types.TooManyTrafficPolicyInstances, decoder smithyxml.NodeDecoder) error { 19251 if v == nil { 19252 return fmt.Errorf("unexpected nil of type %T", v) 19253 } 19254 var sv *types.TooManyTrafficPolicyInstances 19255 if *v == nil { 19256 sv = &types.TooManyTrafficPolicyInstances{} 19257 } else { 19258 sv = *v 19259 } 19260 19261 for { 19262 t, done, err := decoder.Token() 19263 if err != nil { 19264 return err 19265 } 19266 if done { 19267 break 19268 } 19269 originalDecoder := decoder 19270 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19271 switch { 19272 case strings.EqualFold("message", t.Name.Local): 19273 val, err := decoder.Value() 19274 if err != nil { 19275 return err 19276 } 19277 if val == nil { 19278 break 19279 } 19280 { 19281 xtv := string(val) 19282 sv.Message = ptr.String(xtv) 19283 } 19284 19285 default: 19286 // Do nothing and ignore the unexpected tag element 19287 err = decoder.Decoder.Skip() 19288 if err != nil { 19289 return err 19290 } 19291 19292 } 19293 decoder = originalDecoder 19294 } 19295 *v = sv 19296 return nil 19297} 19298 19299func awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(v **types.TooManyTrafficPolicyVersionsForCurrentPolicy, decoder smithyxml.NodeDecoder) error { 19300 if v == nil { 19301 return fmt.Errorf("unexpected nil of type %T", v) 19302 } 19303 var sv *types.TooManyTrafficPolicyVersionsForCurrentPolicy 19304 if *v == nil { 19305 sv = &types.TooManyTrafficPolicyVersionsForCurrentPolicy{} 19306 } else { 19307 sv = *v 19308 } 19309 19310 for { 19311 t, done, err := decoder.Token() 19312 if err != nil { 19313 return err 19314 } 19315 if done { 19316 break 19317 } 19318 originalDecoder := decoder 19319 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19320 switch { 19321 case strings.EqualFold("message", t.Name.Local): 19322 val, err := decoder.Value() 19323 if err != nil { 19324 return err 19325 } 19326 if val == nil { 19327 break 19328 } 19329 { 19330 xtv := string(val) 19331 sv.Message = ptr.String(xtv) 19332 } 19333 19334 default: 19335 // Do nothing and ignore the unexpected tag element 19336 err = decoder.Decoder.Skip() 19337 if err != nil { 19338 return err 19339 } 19340 19341 } 19342 decoder = originalDecoder 19343 } 19344 *v = sv 19345 return nil 19346} 19347 19348func awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(v **types.TooManyVPCAssociationAuthorizations, decoder smithyxml.NodeDecoder) error { 19349 if v == nil { 19350 return fmt.Errorf("unexpected nil of type %T", v) 19351 } 19352 var sv *types.TooManyVPCAssociationAuthorizations 19353 if *v == nil { 19354 sv = &types.TooManyVPCAssociationAuthorizations{} 19355 } else { 19356 sv = *v 19357 } 19358 19359 for { 19360 t, done, err := decoder.Token() 19361 if err != nil { 19362 return err 19363 } 19364 if done { 19365 break 19366 } 19367 originalDecoder := decoder 19368 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19369 switch { 19370 case strings.EqualFold("message", t.Name.Local): 19371 val, err := decoder.Value() 19372 if err != nil { 19373 return err 19374 } 19375 if val == nil { 19376 break 19377 } 19378 { 19379 xtv := string(val) 19380 sv.Message = ptr.String(xtv) 19381 } 19382 19383 default: 19384 // Do nothing and ignore the unexpected tag element 19385 err = decoder.Decoder.Skip() 19386 if err != nil { 19387 return err 19388 } 19389 19390 } 19391 decoder = originalDecoder 19392 } 19393 *v = sv 19394 return nil 19395} 19396 19397func awsRestxml_deserializeDocumentTrafficPolicies(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error { 19398 if v == nil { 19399 return fmt.Errorf("unexpected nil of type %T", v) 19400 } 19401 var sv []types.TrafficPolicy 19402 if *v == nil { 19403 sv = make([]types.TrafficPolicy, 0) 19404 } else { 19405 sv = *v 19406 } 19407 19408 originalDecoder := decoder 19409 for { 19410 t, done, err := decoder.Token() 19411 if err != nil { 19412 return err 19413 } 19414 if done { 19415 break 19416 } 19417 switch { 19418 case strings.EqualFold("TrafficPolicy", t.Name.Local): 19419 var col types.TrafficPolicy 19420 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19421 destAddr := &col 19422 if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil { 19423 return err 19424 } 19425 col = *destAddr 19426 sv = append(sv, col) 19427 19428 default: 19429 err = decoder.Decoder.Skip() 19430 if err != nil { 19431 return err 19432 } 19433 19434 } 19435 decoder = originalDecoder 19436 } 19437 *v = sv 19438 return nil 19439} 19440 19441func awsRestxml_deserializeDocumentTrafficPoliciesUnwrapped(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error { 19442 var sv []types.TrafficPolicy 19443 if *v == nil { 19444 sv = make([]types.TrafficPolicy, 0) 19445 } else { 19446 sv = *v 19447 } 19448 19449 switch { 19450 default: 19451 var mv types.TrafficPolicy 19452 t := decoder.StartEl 19453 _ = t 19454 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19455 destAddr := &mv 19456 if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil { 19457 return err 19458 } 19459 mv = *destAddr 19460 sv = append(sv, mv) 19461 } 19462 *v = sv 19463 return nil 19464} 19465func awsRestxml_deserializeDocumentTrafficPolicy(v **types.TrafficPolicy, decoder smithyxml.NodeDecoder) error { 19466 if v == nil { 19467 return fmt.Errorf("unexpected nil of type %T", v) 19468 } 19469 var sv *types.TrafficPolicy 19470 if *v == nil { 19471 sv = &types.TrafficPolicy{} 19472 } else { 19473 sv = *v 19474 } 19475 19476 for { 19477 t, done, err := decoder.Token() 19478 if err != nil { 19479 return err 19480 } 19481 if done { 19482 break 19483 } 19484 originalDecoder := decoder 19485 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19486 switch { 19487 case strings.EqualFold("Comment", t.Name.Local): 19488 val, err := decoder.Value() 19489 if err != nil { 19490 return err 19491 } 19492 if val == nil { 19493 break 19494 } 19495 { 19496 xtv := string(val) 19497 sv.Comment = ptr.String(xtv) 19498 } 19499 19500 case strings.EqualFold("Document", t.Name.Local): 19501 val, err := decoder.Value() 19502 if err != nil { 19503 return err 19504 } 19505 if val == nil { 19506 break 19507 } 19508 { 19509 xtv := string(val) 19510 sv.Document = ptr.String(xtv) 19511 } 19512 19513 case strings.EqualFold("Id", t.Name.Local): 19514 val, err := decoder.Value() 19515 if err != nil { 19516 return err 19517 } 19518 if val == nil { 19519 break 19520 } 19521 { 19522 xtv := string(val) 19523 sv.Id = ptr.String(xtv) 19524 } 19525 19526 case strings.EqualFold("Name", t.Name.Local): 19527 val, err := decoder.Value() 19528 if err != nil { 19529 return err 19530 } 19531 if val == nil { 19532 break 19533 } 19534 { 19535 xtv := string(val) 19536 sv.Name = ptr.String(xtv) 19537 } 19538 19539 case strings.EqualFold("Type", t.Name.Local): 19540 val, err := decoder.Value() 19541 if err != nil { 19542 return err 19543 } 19544 if val == nil { 19545 break 19546 } 19547 { 19548 xtv := string(val) 19549 sv.Type = types.RRType(xtv) 19550 } 19551 19552 case strings.EqualFold("Version", t.Name.Local): 19553 val, err := decoder.Value() 19554 if err != nil { 19555 return err 19556 } 19557 if val == nil { 19558 break 19559 } 19560 { 19561 xtv := string(val) 19562 i64, err := strconv.ParseInt(xtv, 10, 64) 19563 if err != nil { 19564 return err 19565 } 19566 sv.Version = ptr.Int32(int32(i64)) 19567 } 19568 19569 default: 19570 // Do nothing and ignore the unexpected tag element 19571 err = decoder.Decoder.Skip() 19572 if err != nil { 19573 return err 19574 } 19575 19576 } 19577 decoder = originalDecoder 19578 } 19579 *v = sv 19580 return nil 19581} 19582 19583func awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(v **types.TrafficPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error { 19584 if v == nil { 19585 return fmt.Errorf("unexpected nil of type %T", v) 19586 } 19587 var sv *types.TrafficPolicyAlreadyExists 19588 if *v == nil { 19589 sv = &types.TrafficPolicyAlreadyExists{} 19590 } else { 19591 sv = *v 19592 } 19593 19594 for { 19595 t, done, err := decoder.Token() 19596 if err != nil { 19597 return err 19598 } 19599 if done { 19600 break 19601 } 19602 originalDecoder := decoder 19603 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19604 switch { 19605 case strings.EqualFold("message", t.Name.Local): 19606 val, err := decoder.Value() 19607 if err != nil { 19608 return err 19609 } 19610 if val == nil { 19611 break 19612 } 19613 { 19614 xtv := string(val) 19615 sv.Message = ptr.String(xtv) 19616 } 19617 19618 default: 19619 // Do nothing and ignore the unexpected tag element 19620 err = decoder.Decoder.Skip() 19621 if err != nil { 19622 return err 19623 } 19624 19625 } 19626 decoder = originalDecoder 19627 } 19628 *v = sv 19629 return nil 19630} 19631 19632func awsRestxml_deserializeDocumentTrafficPolicyInstance(v **types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 19633 if v == nil { 19634 return fmt.Errorf("unexpected nil of type %T", v) 19635 } 19636 var sv *types.TrafficPolicyInstance 19637 if *v == nil { 19638 sv = &types.TrafficPolicyInstance{} 19639 } else { 19640 sv = *v 19641 } 19642 19643 for { 19644 t, done, err := decoder.Token() 19645 if err != nil { 19646 return err 19647 } 19648 if done { 19649 break 19650 } 19651 originalDecoder := decoder 19652 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19653 switch { 19654 case strings.EqualFold("HostedZoneId", t.Name.Local): 19655 val, err := decoder.Value() 19656 if err != nil { 19657 return err 19658 } 19659 if val == nil { 19660 break 19661 } 19662 { 19663 xtv := string(val) 19664 sv.HostedZoneId = ptr.String(xtv) 19665 } 19666 19667 case strings.EqualFold("Id", t.Name.Local): 19668 val, err := decoder.Value() 19669 if err != nil { 19670 return err 19671 } 19672 if val == nil { 19673 break 19674 } 19675 { 19676 xtv := string(val) 19677 sv.Id = ptr.String(xtv) 19678 } 19679 19680 case strings.EqualFold("Message", t.Name.Local): 19681 val, err := decoder.Value() 19682 if err != nil { 19683 return err 19684 } 19685 if val == nil { 19686 break 19687 } 19688 { 19689 xtv := string(val) 19690 sv.Message = ptr.String(xtv) 19691 } 19692 19693 case strings.EqualFold("Name", t.Name.Local): 19694 val, err := decoder.Value() 19695 if err != nil { 19696 return err 19697 } 19698 if val == nil { 19699 break 19700 } 19701 { 19702 xtv := string(val) 19703 sv.Name = ptr.String(xtv) 19704 } 19705 19706 case strings.EqualFold("State", t.Name.Local): 19707 val, err := decoder.Value() 19708 if err != nil { 19709 return err 19710 } 19711 if val == nil { 19712 break 19713 } 19714 { 19715 xtv := string(val) 19716 sv.State = ptr.String(xtv) 19717 } 19718 19719 case strings.EqualFold("TrafficPolicyId", t.Name.Local): 19720 val, err := decoder.Value() 19721 if err != nil { 19722 return err 19723 } 19724 if val == nil { 19725 break 19726 } 19727 { 19728 xtv := string(val) 19729 sv.TrafficPolicyId = ptr.String(xtv) 19730 } 19731 19732 case strings.EqualFold("TrafficPolicyType", t.Name.Local): 19733 val, err := decoder.Value() 19734 if err != nil { 19735 return err 19736 } 19737 if val == nil { 19738 break 19739 } 19740 { 19741 xtv := string(val) 19742 sv.TrafficPolicyType = types.RRType(xtv) 19743 } 19744 19745 case strings.EqualFold("TrafficPolicyVersion", t.Name.Local): 19746 val, err := decoder.Value() 19747 if err != nil { 19748 return err 19749 } 19750 if val == nil { 19751 break 19752 } 19753 { 19754 xtv := string(val) 19755 i64, err := strconv.ParseInt(xtv, 10, 64) 19756 if err != nil { 19757 return err 19758 } 19759 sv.TrafficPolicyVersion = ptr.Int32(int32(i64)) 19760 } 19761 19762 case strings.EqualFold("TTL", t.Name.Local): 19763 val, err := decoder.Value() 19764 if err != nil { 19765 return err 19766 } 19767 if val == nil { 19768 break 19769 } 19770 { 19771 xtv := string(val) 19772 i64, err := strconv.ParseInt(xtv, 10, 64) 19773 if err != nil { 19774 return err 19775 } 19776 sv.TTL = ptr.Int64(i64) 19777 } 19778 19779 default: 19780 // Do nothing and ignore the unexpected tag element 19781 err = decoder.Decoder.Skip() 19782 if err != nil { 19783 return err 19784 } 19785 19786 } 19787 decoder = originalDecoder 19788 } 19789 *v = sv 19790 return nil 19791} 19792 19793func awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(v **types.TrafficPolicyInstanceAlreadyExists, decoder smithyxml.NodeDecoder) error { 19794 if v == nil { 19795 return fmt.Errorf("unexpected nil of type %T", v) 19796 } 19797 var sv *types.TrafficPolicyInstanceAlreadyExists 19798 if *v == nil { 19799 sv = &types.TrafficPolicyInstanceAlreadyExists{} 19800 } else { 19801 sv = *v 19802 } 19803 19804 for { 19805 t, done, err := decoder.Token() 19806 if err != nil { 19807 return err 19808 } 19809 if done { 19810 break 19811 } 19812 originalDecoder := decoder 19813 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19814 switch { 19815 case strings.EqualFold("message", t.Name.Local): 19816 val, err := decoder.Value() 19817 if err != nil { 19818 return err 19819 } 19820 if val == nil { 19821 break 19822 } 19823 { 19824 xtv := string(val) 19825 sv.Message = ptr.String(xtv) 19826 } 19827 19828 default: 19829 // Do nothing and ignore the unexpected tag element 19830 err = decoder.Decoder.Skip() 19831 if err != nil { 19832 return err 19833 } 19834 19835 } 19836 decoder = originalDecoder 19837 } 19838 *v = sv 19839 return nil 19840} 19841 19842func awsRestxml_deserializeDocumentTrafficPolicyInstances(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 19843 if v == nil { 19844 return fmt.Errorf("unexpected nil of type %T", v) 19845 } 19846 var sv []types.TrafficPolicyInstance 19847 if *v == nil { 19848 sv = make([]types.TrafficPolicyInstance, 0) 19849 } else { 19850 sv = *v 19851 } 19852 19853 originalDecoder := decoder 19854 for { 19855 t, done, err := decoder.Token() 19856 if err != nil { 19857 return err 19858 } 19859 if done { 19860 break 19861 } 19862 switch { 19863 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 19864 var col types.TrafficPolicyInstance 19865 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19866 destAddr := &col 19867 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil { 19868 return err 19869 } 19870 col = *destAddr 19871 sv = append(sv, col) 19872 19873 default: 19874 err = decoder.Decoder.Skip() 19875 if err != nil { 19876 return err 19877 } 19878 19879 } 19880 decoder = originalDecoder 19881 } 19882 *v = sv 19883 return nil 19884} 19885 19886func awsRestxml_deserializeDocumentTrafficPolicyInstancesUnwrapped(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 19887 var sv []types.TrafficPolicyInstance 19888 if *v == nil { 19889 sv = make([]types.TrafficPolicyInstance, 0) 19890 } else { 19891 sv = *v 19892 } 19893 19894 switch { 19895 default: 19896 var mv types.TrafficPolicyInstance 19897 t := decoder.StartEl 19898 _ = t 19899 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19900 destAddr := &mv 19901 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil { 19902 return err 19903 } 19904 mv = *destAddr 19905 sv = append(sv, mv) 19906 } 19907 *v = sv 19908 return nil 19909} 19910func awsRestxml_deserializeDocumentTrafficPolicyInUse(v **types.TrafficPolicyInUse, decoder smithyxml.NodeDecoder) error { 19911 if v == nil { 19912 return fmt.Errorf("unexpected nil of type %T", v) 19913 } 19914 var sv *types.TrafficPolicyInUse 19915 if *v == nil { 19916 sv = &types.TrafficPolicyInUse{} 19917 } else { 19918 sv = *v 19919 } 19920 19921 for { 19922 t, done, err := decoder.Token() 19923 if err != nil { 19924 return err 19925 } 19926 if done { 19927 break 19928 } 19929 originalDecoder := decoder 19930 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19931 switch { 19932 case strings.EqualFold("message", t.Name.Local): 19933 val, err := decoder.Value() 19934 if err != nil { 19935 return err 19936 } 19937 if val == nil { 19938 break 19939 } 19940 { 19941 xtv := string(val) 19942 sv.Message = ptr.String(xtv) 19943 } 19944 19945 default: 19946 // Do nothing and ignore the unexpected tag element 19947 err = decoder.Decoder.Skip() 19948 if err != nil { 19949 return err 19950 } 19951 19952 } 19953 decoder = originalDecoder 19954 } 19955 *v = sv 19956 return nil 19957} 19958 19959func awsRestxml_deserializeDocumentTrafficPolicySummaries(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error { 19960 if v == nil { 19961 return fmt.Errorf("unexpected nil of type %T", v) 19962 } 19963 var sv []types.TrafficPolicySummary 19964 if *v == nil { 19965 sv = make([]types.TrafficPolicySummary, 0) 19966 } else { 19967 sv = *v 19968 } 19969 19970 originalDecoder := decoder 19971 for { 19972 t, done, err := decoder.Token() 19973 if err != nil { 19974 return err 19975 } 19976 if done { 19977 break 19978 } 19979 switch { 19980 case strings.EqualFold("TrafficPolicySummary", t.Name.Local): 19981 var col types.TrafficPolicySummary 19982 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19983 destAddr := &col 19984 if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil { 19985 return err 19986 } 19987 col = *destAddr 19988 sv = append(sv, col) 19989 19990 default: 19991 err = decoder.Decoder.Skip() 19992 if err != nil { 19993 return err 19994 } 19995 19996 } 19997 decoder = originalDecoder 19998 } 19999 *v = sv 20000 return nil 20001} 20002 20003func awsRestxml_deserializeDocumentTrafficPolicySummariesUnwrapped(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error { 20004 var sv []types.TrafficPolicySummary 20005 if *v == nil { 20006 sv = make([]types.TrafficPolicySummary, 0) 20007 } else { 20008 sv = *v 20009 } 20010 20011 switch { 20012 default: 20013 var mv types.TrafficPolicySummary 20014 t := decoder.StartEl 20015 _ = t 20016 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20017 destAddr := &mv 20018 if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil { 20019 return err 20020 } 20021 mv = *destAddr 20022 sv = append(sv, mv) 20023 } 20024 *v = sv 20025 return nil 20026} 20027func awsRestxml_deserializeDocumentTrafficPolicySummary(v **types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error { 20028 if v == nil { 20029 return fmt.Errorf("unexpected nil of type %T", v) 20030 } 20031 var sv *types.TrafficPolicySummary 20032 if *v == nil { 20033 sv = &types.TrafficPolicySummary{} 20034 } else { 20035 sv = *v 20036 } 20037 20038 for { 20039 t, done, err := decoder.Token() 20040 if err != nil { 20041 return err 20042 } 20043 if done { 20044 break 20045 } 20046 originalDecoder := decoder 20047 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20048 switch { 20049 case strings.EqualFold("Id", t.Name.Local): 20050 val, err := decoder.Value() 20051 if err != nil { 20052 return err 20053 } 20054 if val == nil { 20055 break 20056 } 20057 { 20058 xtv := string(val) 20059 sv.Id = ptr.String(xtv) 20060 } 20061 20062 case strings.EqualFold("LatestVersion", t.Name.Local): 20063 val, err := decoder.Value() 20064 if err != nil { 20065 return err 20066 } 20067 if val == nil { 20068 break 20069 } 20070 { 20071 xtv := string(val) 20072 i64, err := strconv.ParseInt(xtv, 10, 64) 20073 if err != nil { 20074 return err 20075 } 20076 sv.LatestVersion = ptr.Int32(int32(i64)) 20077 } 20078 20079 case strings.EqualFold("Name", t.Name.Local): 20080 val, err := decoder.Value() 20081 if err != nil { 20082 return err 20083 } 20084 if val == nil { 20085 break 20086 } 20087 { 20088 xtv := string(val) 20089 sv.Name = ptr.String(xtv) 20090 } 20091 20092 case strings.EqualFold("TrafficPolicyCount", t.Name.Local): 20093 val, err := decoder.Value() 20094 if err != nil { 20095 return err 20096 } 20097 if val == nil { 20098 break 20099 } 20100 { 20101 xtv := string(val) 20102 i64, err := strconv.ParseInt(xtv, 10, 64) 20103 if err != nil { 20104 return err 20105 } 20106 sv.TrafficPolicyCount = ptr.Int32(int32(i64)) 20107 } 20108 20109 case strings.EqualFold("Type", t.Name.Local): 20110 val, err := decoder.Value() 20111 if err != nil { 20112 return err 20113 } 20114 if val == nil { 20115 break 20116 } 20117 { 20118 xtv := string(val) 20119 sv.Type = types.RRType(xtv) 20120 } 20121 20122 default: 20123 // Do nothing and ignore the unexpected tag element 20124 err = decoder.Decoder.Skip() 20125 if err != nil { 20126 return err 20127 } 20128 20129 } 20130 decoder = originalDecoder 20131 } 20132 *v = sv 20133 return nil 20134} 20135 20136func awsRestxml_deserializeDocumentVPC(v **types.VPC, decoder smithyxml.NodeDecoder) error { 20137 if v == nil { 20138 return fmt.Errorf("unexpected nil of type %T", v) 20139 } 20140 var sv *types.VPC 20141 if *v == nil { 20142 sv = &types.VPC{} 20143 } else { 20144 sv = *v 20145 } 20146 20147 for { 20148 t, done, err := decoder.Token() 20149 if err != nil { 20150 return err 20151 } 20152 if done { 20153 break 20154 } 20155 originalDecoder := decoder 20156 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20157 switch { 20158 case strings.EqualFold("VPCId", t.Name.Local): 20159 val, err := decoder.Value() 20160 if err != nil { 20161 return err 20162 } 20163 if val == nil { 20164 break 20165 } 20166 { 20167 xtv := string(val) 20168 sv.VPCId = ptr.String(xtv) 20169 } 20170 20171 case strings.EqualFold("VPCRegion", t.Name.Local): 20172 val, err := decoder.Value() 20173 if err != nil { 20174 return err 20175 } 20176 if val == nil { 20177 break 20178 } 20179 { 20180 xtv := string(val) 20181 sv.VPCRegion = types.VPCRegion(xtv) 20182 } 20183 20184 default: 20185 // Do nothing and ignore the unexpected tag element 20186 err = decoder.Decoder.Skip() 20187 if err != nil { 20188 return err 20189 } 20190 20191 } 20192 decoder = originalDecoder 20193 } 20194 *v = sv 20195 return nil 20196} 20197 20198func awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(v **types.VPCAssociationAuthorizationNotFound, decoder smithyxml.NodeDecoder) error { 20199 if v == nil { 20200 return fmt.Errorf("unexpected nil of type %T", v) 20201 } 20202 var sv *types.VPCAssociationAuthorizationNotFound 20203 if *v == nil { 20204 sv = &types.VPCAssociationAuthorizationNotFound{} 20205 } else { 20206 sv = *v 20207 } 20208 20209 for { 20210 t, done, err := decoder.Token() 20211 if err != nil { 20212 return err 20213 } 20214 if done { 20215 break 20216 } 20217 originalDecoder := decoder 20218 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20219 switch { 20220 case strings.EqualFold("message", t.Name.Local): 20221 val, err := decoder.Value() 20222 if err != nil { 20223 return err 20224 } 20225 if val == nil { 20226 break 20227 } 20228 { 20229 xtv := string(val) 20230 sv.Message = ptr.String(xtv) 20231 } 20232 20233 default: 20234 // Do nothing and ignore the unexpected tag element 20235 err = decoder.Decoder.Skip() 20236 if err != nil { 20237 return err 20238 } 20239 20240 } 20241 decoder = originalDecoder 20242 } 20243 *v = sv 20244 return nil 20245} 20246 20247func awsRestxml_deserializeDocumentVPCAssociationNotFound(v **types.VPCAssociationNotFound, decoder smithyxml.NodeDecoder) error { 20248 if v == nil { 20249 return fmt.Errorf("unexpected nil of type %T", v) 20250 } 20251 var sv *types.VPCAssociationNotFound 20252 if *v == nil { 20253 sv = &types.VPCAssociationNotFound{} 20254 } else { 20255 sv = *v 20256 } 20257 20258 for { 20259 t, done, err := decoder.Token() 20260 if err != nil { 20261 return err 20262 } 20263 if done { 20264 break 20265 } 20266 originalDecoder := decoder 20267 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20268 switch { 20269 case strings.EqualFold("message", t.Name.Local): 20270 val, err := decoder.Value() 20271 if err != nil { 20272 return err 20273 } 20274 if val == nil { 20275 break 20276 } 20277 { 20278 xtv := string(val) 20279 sv.Message = ptr.String(xtv) 20280 } 20281 20282 default: 20283 // Do nothing and ignore the unexpected tag element 20284 err = decoder.Decoder.Skip() 20285 if err != nil { 20286 return err 20287 } 20288 20289 } 20290 decoder = originalDecoder 20291 } 20292 *v = sv 20293 return nil 20294} 20295 20296func awsRestxml_deserializeDocumentVPCs(v *[]types.VPC, decoder smithyxml.NodeDecoder) error { 20297 if v == nil { 20298 return fmt.Errorf("unexpected nil of type %T", v) 20299 } 20300 var sv []types.VPC 20301 if *v == nil { 20302 sv = make([]types.VPC, 0) 20303 } else { 20304 sv = *v 20305 } 20306 20307 originalDecoder := decoder 20308 for { 20309 t, done, err := decoder.Token() 20310 if err != nil { 20311 return err 20312 } 20313 if done { 20314 break 20315 } 20316 switch { 20317 case strings.EqualFold("VPC", t.Name.Local): 20318 var col types.VPC 20319 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20320 destAddr := &col 20321 if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil { 20322 return err 20323 } 20324 col = *destAddr 20325 sv = append(sv, col) 20326 20327 default: 20328 err = decoder.Decoder.Skip() 20329 if err != nil { 20330 return err 20331 } 20332 20333 } 20334 decoder = originalDecoder 20335 } 20336 *v = sv 20337 return nil 20338} 20339 20340func awsRestxml_deserializeDocumentVPCsUnwrapped(v *[]types.VPC, decoder smithyxml.NodeDecoder) error { 20341 var sv []types.VPC 20342 if *v == nil { 20343 sv = make([]types.VPC, 0) 20344 } else { 20345 sv = *v 20346 } 20347 20348 switch { 20349 default: 20350 var mv types.VPC 20351 t := decoder.StartEl 20352 _ = t 20353 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20354 destAddr := &mv 20355 if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil { 20356 return err 20357 } 20358 mv = *destAddr 20359 sv = append(sv, mv) 20360 } 20361 *v = sv 20362 return nil 20363} 20364