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("InvalidInput", errorCode): 111 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 112 113 case strings.EqualFold("InvalidKMSArn", errorCode): 114 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 115 116 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 117 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 118 119 case strings.EqualFold("InvalidSigningStatus", errorCode): 120 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 121 122 case strings.EqualFold("NoSuchKeySigningKey", errorCode): 123 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody) 124 125 default: 126 genericError := &smithy.GenericAPIError{ 127 Code: errorCode, 128 Message: errorMessage, 129 } 130 return genericError 131 132 } 133} 134 135func awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(v **ActivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 136 if v == nil { 137 return fmt.Errorf("unexpected nil of type %T", v) 138 } 139 var sv *ActivateKeySigningKeyOutput 140 if *v == nil { 141 sv = &ActivateKeySigningKeyOutput{} 142 } else { 143 sv = *v 144 } 145 146 for { 147 t, done, err := decoder.Token() 148 if err != nil { 149 return err 150 } 151 if done { 152 break 153 } 154 originalDecoder := decoder 155 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 156 switch { 157 case strings.EqualFold("ChangeInfo", t.Name.Local): 158 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 159 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 160 return err 161 } 162 163 default: 164 // Do nothing and ignore the unexpected tag element 165 err = decoder.Decoder.Skip() 166 if err != nil { 167 return err 168 } 169 170 } 171 decoder = originalDecoder 172 } 173 *v = sv 174 return nil 175} 176 177type awsRestxml_deserializeOpAssociateVPCWithHostedZone struct { 178} 179 180func (*awsRestxml_deserializeOpAssociateVPCWithHostedZone) ID() string { 181 return "OperationDeserializer" 182} 183 184func (m *awsRestxml_deserializeOpAssociateVPCWithHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 185 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 186) { 187 out, metadata, err = next.HandleDeserialize(ctx, in) 188 if err != nil { 189 return out, metadata, err 190 } 191 192 response, ok := out.RawResponse.(*smithyhttp.Response) 193 if !ok { 194 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 195 } 196 197 if response.StatusCode < 200 || response.StatusCode >= 300 { 198 return out, metadata, awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response, &metadata) 199 } 200 output := &AssociateVPCWithHostedZoneOutput{} 201 out.Result = output 202 203 var buff [1024]byte 204 ringBuffer := smithyio.NewRingBuffer(buff[:]) 205 body := io.TeeReader(response.Body, ringBuffer) 206 rootDecoder := xml.NewDecoder(body) 207 t, err := smithyxml.FetchRootElement(rootDecoder) 208 if err == io.EOF { 209 return out, metadata, nil 210 } 211 if err != nil { 212 var snapshot bytes.Buffer 213 io.Copy(&snapshot, ringBuffer) 214 return out, metadata, &smithy.DeserializationError{ 215 Err: fmt.Errorf("failed to decode response body, %w", err), 216 Snapshot: snapshot.Bytes(), 217 } 218 } 219 220 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 221 err = awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(&output, decoder) 222 if err != nil { 223 var snapshot bytes.Buffer 224 io.Copy(&snapshot, ringBuffer) 225 return out, metadata, &smithy.DeserializationError{ 226 Err: fmt.Errorf("failed to decode response body, %w", err), 227 Snapshot: snapshot.Bytes(), 228 } 229 } 230 231 return out, metadata, err 232} 233 234func awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 235 var errorBuffer bytes.Buffer 236 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 237 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 238 } 239 errorBody := bytes.NewReader(errorBuffer.Bytes()) 240 241 errorCode := "UnknownError" 242 errorMessage := errorCode 243 244 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 245 if err != nil { 246 return err 247 } 248 if reqID := errorComponents.RequestID; len(reqID) != 0 { 249 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 250 } 251 if len(errorComponents.Code) != 0 { 252 errorCode = errorComponents.Code 253 } 254 if len(errorComponents.Message) != 0 { 255 errorMessage = errorComponents.Message 256 } 257 errorBody.Seek(0, io.SeekStart) 258 switch { 259 case strings.EqualFold("ConflictingDomainExists", errorCode): 260 return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody) 261 262 case strings.EqualFold("InvalidInput", errorCode): 263 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 264 265 case strings.EqualFold("InvalidVPCId", errorCode): 266 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 267 268 case strings.EqualFold("LimitsExceeded", errorCode): 269 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody) 270 271 case strings.EqualFold("NoSuchHostedZone", errorCode): 272 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 273 274 case strings.EqualFold("NotAuthorizedException", errorCode): 275 return awsRestxml_deserializeErrorNotAuthorizedException(response, errorBody) 276 277 case strings.EqualFold("PriorRequestNotComplete", errorCode): 278 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 279 280 case strings.EqualFold("PublicZoneVPCAssociation", errorCode): 281 return awsRestxml_deserializeErrorPublicZoneVPCAssociation(response, errorBody) 282 283 default: 284 genericError := &smithy.GenericAPIError{ 285 Code: errorCode, 286 Message: errorMessage, 287 } 288 return genericError 289 290 } 291} 292 293func awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(v **AssociateVPCWithHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 294 if v == nil { 295 return fmt.Errorf("unexpected nil of type %T", v) 296 } 297 var sv *AssociateVPCWithHostedZoneOutput 298 if *v == nil { 299 sv = &AssociateVPCWithHostedZoneOutput{} 300 } else { 301 sv = *v 302 } 303 304 for { 305 t, done, err := decoder.Token() 306 if err != nil { 307 return err 308 } 309 if done { 310 break 311 } 312 originalDecoder := decoder 313 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 314 switch { 315 case strings.EqualFold("ChangeInfo", t.Name.Local): 316 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 317 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 318 return err 319 } 320 321 default: 322 // Do nothing and ignore the unexpected tag element 323 err = decoder.Decoder.Skip() 324 if err != nil { 325 return err 326 } 327 328 } 329 decoder = originalDecoder 330 } 331 *v = sv 332 return nil 333} 334 335type awsRestxml_deserializeOpChangeResourceRecordSets struct { 336} 337 338func (*awsRestxml_deserializeOpChangeResourceRecordSets) ID() string { 339 return "OperationDeserializer" 340} 341 342func (m *awsRestxml_deserializeOpChangeResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 343 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 344) { 345 out, metadata, err = next.HandleDeserialize(ctx, in) 346 if err != nil { 347 return out, metadata, err 348 } 349 350 response, ok := out.RawResponse.(*smithyhttp.Response) 351 if !ok { 352 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 353 } 354 355 if response.StatusCode < 200 || response.StatusCode >= 300 { 356 return out, metadata, awsRestxml_deserializeOpErrorChangeResourceRecordSets(response, &metadata) 357 } 358 output := &ChangeResourceRecordSetsOutput{} 359 out.Result = output 360 361 var buff [1024]byte 362 ringBuffer := smithyio.NewRingBuffer(buff[:]) 363 body := io.TeeReader(response.Body, ringBuffer) 364 rootDecoder := xml.NewDecoder(body) 365 t, err := smithyxml.FetchRootElement(rootDecoder) 366 if err == io.EOF { 367 return out, metadata, nil 368 } 369 if err != nil { 370 var snapshot bytes.Buffer 371 io.Copy(&snapshot, ringBuffer) 372 return out, metadata, &smithy.DeserializationError{ 373 Err: fmt.Errorf("failed to decode response body, %w", err), 374 Snapshot: snapshot.Bytes(), 375 } 376 } 377 378 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 379 err = awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(&output, decoder) 380 if err != nil { 381 var snapshot bytes.Buffer 382 io.Copy(&snapshot, ringBuffer) 383 return out, metadata, &smithy.DeserializationError{ 384 Err: fmt.Errorf("failed to decode response body, %w", err), 385 Snapshot: snapshot.Bytes(), 386 } 387 } 388 389 return out, metadata, err 390} 391 392func awsRestxml_deserializeOpErrorChangeResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 393 var errorBuffer bytes.Buffer 394 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 395 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 396 } 397 errorBody := bytes.NewReader(errorBuffer.Bytes()) 398 399 errorCode := "UnknownError" 400 errorMessage := errorCode 401 402 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 403 if err != nil { 404 return err 405 } 406 if reqID := errorComponents.RequestID; len(reqID) != 0 { 407 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 408 } 409 if len(errorComponents.Code) != 0 { 410 errorCode = errorComponents.Code 411 } 412 if len(errorComponents.Message) != 0 { 413 errorMessage = errorComponents.Message 414 } 415 errorBody.Seek(0, io.SeekStart) 416 switch { 417 case strings.EqualFold("InvalidChangeBatch", errorCode): 418 return awsRestxml_deserializeErrorInvalidChangeBatch(response, errorBody) 419 420 case strings.EqualFold("InvalidInput", errorCode): 421 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 422 423 case strings.EqualFold("NoSuchHealthCheck", errorCode): 424 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 425 426 case strings.EqualFold("NoSuchHostedZone", errorCode): 427 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 428 429 case strings.EqualFold("PriorRequestNotComplete", errorCode): 430 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 431 432 default: 433 genericError := &smithy.GenericAPIError{ 434 Code: errorCode, 435 Message: errorMessage, 436 } 437 return genericError 438 439 } 440} 441 442func awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(v **ChangeResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error { 443 if v == nil { 444 return fmt.Errorf("unexpected nil of type %T", v) 445 } 446 var sv *ChangeResourceRecordSetsOutput 447 if *v == nil { 448 sv = &ChangeResourceRecordSetsOutput{} 449 } else { 450 sv = *v 451 } 452 453 for { 454 t, done, err := decoder.Token() 455 if err != nil { 456 return err 457 } 458 if done { 459 break 460 } 461 originalDecoder := decoder 462 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 463 switch { 464 case strings.EqualFold("ChangeInfo", t.Name.Local): 465 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 466 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 467 return err 468 } 469 470 default: 471 // Do nothing and ignore the unexpected tag element 472 err = decoder.Decoder.Skip() 473 if err != nil { 474 return err 475 } 476 477 } 478 decoder = originalDecoder 479 } 480 *v = sv 481 return nil 482} 483 484type awsRestxml_deserializeOpChangeTagsForResource struct { 485} 486 487func (*awsRestxml_deserializeOpChangeTagsForResource) ID() string { 488 return "OperationDeserializer" 489} 490 491func (m *awsRestxml_deserializeOpChangeTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 492 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 493) { 494 out, metadata, err = next.HandleDeserialize(ctx, in) 495 if err != nil { 496 return out, metadata, err 497 } 498 499 response, ok := out.RawResponse.(*smithyhttp.Response) 500 if !ok { 501 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 502 } 503 504 if response.StatusCode < 200 || response.StatusCode >= 300 { 505 return out, metadata, awsRestxml_deserializeOpErrorChangeTagsForResource(response, &metadata) 506 } 507 output := &ChangeTagsForResourceOutput{} 508 out.Result = output 509 510 return out, metadata, err 511} 512 513func awsRestxml_deserializeOpErrorChangeTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 514 var errorBuffer bytes.Buffer 515 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 516 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 517 } 518 errorBody := bytes.NewReader(errorBuffer.Bytes()) 519 520 errorCode := "UnknownError" 521 errorMessage := errorCode 522 523 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 524 if err != nil { 525 return err 526 } 527 if reqID := errorComponents.RequestID; len(reqID) != 0 { 528 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 529 } 530 if len(errorComponents.Code) != 0 { 531 errorCode = errorComponents.Code 532 } 533 if len(errorComponents.Message) != 0 { 534 errorMessage = errorComponents.Message 535 } 536 errorBody.Seek(0, io.SeekStart) 537 switch { 538 case strings.EqualFold("InvalidInput", errorCode): 539 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 540 541 case strings.EqualFold("NoSuchHealthCheck", errorCode): 542 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 543 544 case strings.EqualFold("NoSuchHostedZone", errorCode): 545 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 546 547 case strings.EqualFold("PriorRequestNotComplete", errorCode): 548 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 549 550 case strings.EqualFold("ThrottlingException", errorCode): 551 return awsRestxml_deserializeErrorThrottlingException(response, errorBody) 552 553 default: 554 genericError := &smithy.GenericAPIError{ 555 Code: errorCode, 556 Message: errorMessage, 557 } 558 return genericError 559 560 } 561} 562 563type awsRestxml_deserializeOpCreateHealthCheck struct { 564} 565 566func (*awsRestxml_deserializeOpCreateHealthCheck) ID() string { 567 return "OperationDeserializer" 568} 569 570func (m *awsRestxml_deserializeOpCreateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 571 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 572) { 573 out, metadata, err = next.HandleDeserialize(ctx, in) 574 if err != nil { 575 return out, metadata, err 576 } 577 578 response, ok := out.RawResponse.(*smithyhttp.Response) 579 if !ok { 580 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 581 } 582 583 if response.StatusCode < 200 || response.StatusCode >= 300 { 584 return out, metadata, awsRestxml_deserializeOpErrorCreateHealthCheck(response, &metadata) 585 } 586 output := &CreateHealthCheckOutput{} 587 out.Result = output 588 589 err = awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(output, response) 590 if err != nil { 591 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 592 } 593 594 var buff [1024]byte 595 ringBuffer := smithyio.NewRingBuffer(buff[:]) 596 body := io.TeeReader(response.Body, ringBuffer) 597 rootDecoder := xml.NewDecoder(body) 598 t, err := smithyxml.FetchRootElement(rootDecoder) 599 if err == io.EOF { 600 return out, metadata, nil 601 } 602 if err != nil { 603 var snapshot bytes.Buffer 604 io.Copy(&snapshot, ringBuffer) 605 return out, metadata, &smithy.DeserializationError{ 606 Err: fmt.Errorf("failed to decode response body, %w", err), 607 Snapshot: snapshot.Bytes(), 608 } 609 } 610 611 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 612 err = awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(&output, decoder) 613 if err != nil { 614 var snapshot bytes.Buffer 615 io.Copy(&snapshot, ringBuffer) 616 return out, metadata, &smithy.DeserializationError{ 617 Err: fmt.Errorf("failed to decode response body, %w", err), 618 Snapshot: snapshot.Bytes(), 619 } 620 } 621 622 return out, metadata, err 623} 624 625func awsRestxml_deserializeOpErrorCreateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 626 var errorBuffer bytes.Buffer 627 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 628 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 629 } 630 errorBody := bytes.NewReader(errorBuffer.Bytes()) 631 632 errorCode := "UnknownError" 633 errorMessage := errorCode 634 635 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 636 if err != nil { 637 return err 638 } 639 if reqID := errorComponents.RequestID; len(reqID) != 0 { 640 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 641 } 642 if len(errorComponents.Code) != 0 { 643 errorCode = errorComponents.Code 644 } 645 if len(errorComponents.Message) != 0 { 646 errorMessage = errorComponents.Message 647 } 648 errorBody.Seek(0, io.SeekStart) 649 switch { 650 case strings.EqualFold("HealthCheckAlreadyExists", errorCode): 651 return awsRestxml_deserializeErrorHealthCheckAlreadyExists(response, errorBody) 652 653 case strings.EqualFold("InvalidInput", errorCode): 654 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 655 656 case strings.EqualFold("TooManyHealthChecks", errorCode): 657 return awsRestxml_deserializeErrorTooManyHealthChecks(response, errorBody) 658 659 default: 660 genericError := &smithy.GenericAPIError{ 661 Code: errorCode, 662 Message: errorMessage, 663 } 664 return genericError 665 666 } 667} 668 669func awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(v *CreateHealthCheckOutput, response *smithyhttp.Response) error { 670 if v == nil { 671 return fmt.Errorf("unsupported deserialization for nil %T", v) 672 } 673 674 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 675 headerValues[0] = strings.TrimSpace(headerValues[0]) 676 v.Location = ptr.String(headerValues[0]) 677 } 678 679 return nil 680} 681func awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(v **CreateHealthCheckOutput, decoder smithyxml.NodeDecoder) error { 682 if v == nil { 683 return fmt.Errorf("unexpected nil of type %T", v) 684 } 685 var sv *CreateHealthCheckOutput 686 if *v == nil { 687 sv = &CreateHealthCheckOutput{} 688 } else { 689 sv = *v 690 } 691 692 for { 693 t, done, err := decoder.Token() 694 if err != nil { 695 return err 696 } 697 if done { 698 break 699 } 700 originalDecoder := decoder 701 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 702 switch { 703 case strings.EqualFold("HealthCheck", t.Name.Local): 704 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 705 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil { 706 return err 707 } 708 709 default: 710 // Do nothing and ignore the unexpected tag element 711 err = decoder.Decoder.Skip() 712 if err != nil { 713 return err 714 } 715 716 } 717 decoder = originalDecoder 718 } 719 *v = sv 720 return nil 721} 722 723type awsRestxml_deserializeOpCreateHostedZone struct { 724} 725 726func (*awsRestxml_deserializeOpCreateHostedZone) ID() string { 727 return "OperationDeserializer" 728} 729 730func (m *awsRestxml_deserializeOpCreateHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 731 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 732) { 733 out, metadata, err = next.HandleDeserialize(ctx, in) 734 if err != nil { 735 return out, metadata, err 736 } 737 738 response, ok := out.RawResponse.(*smithyhttp.Response) 739 if !ok { 740 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 741 } 742 743 if response.StatusCode < 200 || response.StatusCode >= 300 { 744 return out, metadata, awsRestxml_deserializeOpErrorCreateHostedZone(response, &metadata) 745 } 746 output := &CreateHostedZoneOutput{} 747 out.Result = output 748 749 err = awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(output, response) 750 if err != nil { 751 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 752 } 753 754 var buff [1024]byte 755 ringBuffer := smithyio.NewRingBuffer(buff[:]) 756 body := io.TeeReader(response.Body, ringBuffer) 757 rootDecoder := xml.NewDecoder(body) 758 t, err := smithyxml.FetchRootElement(rootDecoder) 759 if err == io.EOF { 760 return out, metadata, nil 761 } 762 if err != nil { 763 var snapshot bytes.Buffer 764 io.Copy(&snapshot, ringBuffer) 765 return out, metadata, &smithy.DeserializationError{ 766 Err: fmt.Errorf("failed to decode response body, %w", err), 767 Snapshot: snapshot.Bytes(), 768 } 769 } 770 771 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 772 err = awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(&output, decoder) 773 if err != nil { 774 var snapshot bytes.Buffer 775 io.Copy(&snapshot, ringBuffer) 776 return out, metadata, &smithy.DeserializationError{ 777 Err: fmt.Errorf("failed to decode response body, %w", err), 778 Snapshot: snapshot.Bytes(), 779 } 780 } 781 782 return out, metadata, err 783} 784 785func awsRestxml_deserializeOpErrorCreateHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 786 var errorBuffer bytes.Buffer 787 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 788 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 789 } 790 errorBody := bytes.NewReader(errorBuffer.Bytes()) 791 792 errorCode := "UnknownError" 793 errorMessage := errorCode 794 795 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 796 if err != nil { 797 return err 798 } 799 if reqID := errorComponents.RequestID; len(reqID) != 0 { 800 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 801 } 802 if len(errorComponents.Code) != 0 { 803 errorCode = errorComponents.Code 804 } 805 if len(errorComponents.Message) != 0 { 806 errorMessage = errorComponents.Message 807 } 808 errorBody.Seek(0, io.SeekStart) 809 switch { 810 case strings.EqualFold("ConflictingDomainExists", errorCode): 811 return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody) 812 813 case strings.EqualFold("DelegationSetNotAvailable", errorCode): 814 return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody) 815 816 case strings.EqualFold("DelegationSetNotReusable", errorCode): 817 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 818 819 case strings.EqualFold("HostedZoneAlreadyExists", errorCode): 820 return awsRestxml_deserializeErrorHostedZoneAlreadyExists(response, errorBody) 821 822 case strings.EqualFold("InvalidDomainName", errorCode): 823 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody) 824 825 case strings.EqualFold("InvalidInput", errorCode): 826 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 827 828 case strings.EqualFold("InvalidVPCId", errorCode): 829 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 830 831 case strings.EqualFold("NoSuchDelegationSet", errorCode): 832 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 833 834 case strings.EqualFold("TooManyHostedZones", errorCode): 835 return awsRestxml_deserializeErrorTooManyHostedZones(response, errorBody) 836 837 default: 838 genericError := &smithy.GenericAPIError{ 839 Code: errorCode, 840 Message: errorMessage, 841 } 842 return genericError 843 844 } 845} 846 847func awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(v *CreateHostedZoneOutput, response *smithyhttp.Response) error { 848 if v == nil { 849 return fmt.Errorf("unsupported deserialization for nil %T", v) 850 } 851 852 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 853 headerValues[0] = strings.TrimSpace(headerValues[0]) 854 v.Location = ptr.String(headerValues[0]) 855 } 856 857 return nil 858} 859func awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(v **CreateHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 860 if v == nil { 861 return fmt.Errorf("unexpected nil of type %T", v) 862 } 863 var sv *CreateHostedZoneOutput 864 if *v == nil { 865 sv = &CreateHostedZoneOutput{} 866 } else { 867 sv = *v 868 } 869 870 for { 871 t, done, err := decoder.Token() 872 if err != nil { 873 return err 874 } 875 if done { 876 break 877 } 878 originalDecoder := decoder 879 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 880 switch { 881 case strings.EqualFold("ChangeInfo", t.Name.Local): 882 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 883 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 884 return err 885 } 886 887 case strings.EqualFold("DelegationSet", t.Name.Local): 888 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 889 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 890 return err 891 } 892 893 case strings.EqualFold("HostedZone", t.Name.Local): 894 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 895 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil { 896 return err 897 } 898 899 case strings.EqualFold("VPC", t.Name.Local): 900 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 901 if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil { 902 return err 903 } 904 905 default: 906 // Do nothing and ignore the unexpected tag element 907 err = decoder.Decoder.Skip() 908 if err != nil { 909 return err 910 } 911 912 } 913 decoder = originalDecoder 914 } 915 *v = sv 916 return nil 917} 918 919type awsRestxml_deserializeOpCreateKeySigningKey struct { 920} 921 922func (*awsRestxml_deserializeOpCreateKeySigningKey) ID() string { 923 return "OperationDeserializer" 924} 925 926func (m *awsRestxml_deserializeOpCreateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 927 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 928) { 929 out, metadata, err = next.HandleDeserialize(ctx, in) 930 if err != nil { 931 return out, metadata, err 932 } 933 934 response, ok := out.RawResponse.(*smithyhttp.Response) 935 if !ok { 936 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 937 } 938 939 if response.StatusCode < 200 || response.StatusCode >= 300 { 940 return out, metadata, awsRestxml_deserializeOpErrorCreateKeySigningKey(response, &metadata) 941 } 942 output := &CreateKeySigningKeyOutput{} 943 out.Result = output 944 945 err = awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(output, response) 946 if err != nil { 947 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 948 } 949 950 var buff [1024]byte 951 ringBuffer := smithyio.NewRingBuffer(buff[:]) 952 body := io.TeeReader(response.Body, ringBuffer) 953 rootDecoder := xml.NewDecoder(body) 954 t, err := smithyxml.FetchRootElement(rootDecoder) 955 if err == io.EOF { 956 return out, metadata, nil 957 } 958 if err != nil { 959 var snapshot bytes.Buffer 960 io.Copy(&snapshot, ringBuffer) 961 return out, metadata, &smithy.DeserializationError{ 962 Err: fmt.Errorf("failed to decode response body, %w", err), 963 Snapshot: snapshot.Bytes(), 964 } 965 } 966 967 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 968 err = awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(&output, decoder) 969 if err != nil { 970 var snapshot bytes.Buffer 971 io.Copy(&snapshot, ringBuffer) 972 return out, metadata, &smithy.DeserializationError{ 973 Err: fmt.Errorf("failed to decode response body, %w", err), 974 Snapshot: snapshot.Bytes(), 975 } 976 } 977 978 return out, metadata, err 979} 980 981func awsRestxml_deserializeOpErrorCreateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 982 var errorBuffer bytes.Buffer 983 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 984 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 985 } 986 errorBody := bytes.NewReader(errorBuffer.Bytes()) 987 988 errorCode := "UnknownError" 989 errorMessage := errorCode 990 991 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 992 if err != nil { 993 return err 994 } 995 if reqID := errorComponents.RequestID; len(reqID) != 0 { 996 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 997 } 998 if len(errorComponents.Code) != 0 { 999 errorCode = errorComponents.Code 1000 } 1001 if len(errorComponents.Message) != 0 { 1002 errorMessage = errorComponents.Message 1003 } 1004 errorBody.Seek(0, io.SeekStart) 1005 switch { 1006 case strings.EqualFold("ConcurrentModification", errorCode): 1007 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 1008 1009 case strings.EqualFold("InvalidArgument", errorCode): 1010 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 1011 1012 case strings.EqualFold("InvalidInput", errorCode): 1013 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1014 1015 case strings.EqualFold("InvalidKMSArn", errorCode): 1016 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 1017 1018 case strings.EqualFold("InvalidKeySigningKeyName", errorCode): 1019 return awsRestxml_deserializeErrorInvalidKeySigningKeyName(response, errorBody) 1020 1021 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 1022 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 1023 1024 case strings.EqualFold("InvalidSigningStatus", errorCode): 1025 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 1026 1027 case strings.EqualFold("KeySigningKeyAlreadyExists", errorCode): 1028 return awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response, errorBody) 1029 1030 case strings.EqualFold("NoSuchHostedZone", errorCode): 1031 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 1032 1033 case strings.EqualFold("TooManyKeySigningKeys", errorCode): 1034 return awsRestxml_deserializeErrorTooManyKeySigningKeys(response, errorBody) 1035 1036 default: 1037 genericError := &smithy.GenericAPIError{ 1038 Code: errorCode, 1039 Message: errorMessage, 1040 } 1041 return genericError 1042 1043 } 1044} 1045 1046func awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(v *CreateKeySigningKeyOutput, response *smithyhttp.Response) error { 1047 if v == nil { 1048 return fmt.Errorf("unsupported deserialization for nil %T", v) 1049 } 1050 1051 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1052 headerValues[0] = strings.TrimSpace(headerValues[0]) 1053 v.Location = ptr.String(headerValues[0]) 1054 } 1055 1056 return nil 1057} 1058func awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(v **CreateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 1059 if v == nil { 1060 return fmt.Errorf("unexpected nil of type %T", v) 1061 } 1062 var sv *CreateKeySigningKeyOutput 1063 if *v == nil { 1064 sv = &CreateKeySigningKeyOutput{} 1065 } else { 1066 sv = *v 1067 } 1068 1069 for { 1070 t, done, err := decoder.Token() 1071 if err != nil { 1072 return err 1073 } 1074 if done { 1075 break 1076 } 1077 originalDecoder := decoder 1078 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1079 switch { 1080 case strings.EqualFold("ChangeInfo", t.Name.Local): 1081 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1082 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 1083 return err 1084 } 1085 1086 case strings.EqualFold("KeySigningKey", t.Name.Local): 1087 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1088 if err := awsRestxml_deserializeDocumentKeySigningKey(&sv.KeySigningKey, nodeDecoder); err != nil { 1089 return err 1090 } 1091 1092 default: 1093 // Do nothing and ignore the unexpected tag element 1094 err = decoder.Decoder.Skip() 1095 if err != nil { 1096 return err 1097 } 1098 1099 } 1100 decoder = originalDecoder 1101 } 1102 *v = sv 1103 return nil 1104} 1105 1106type awsRestxml_deserializeOpCreateQueryLoggingConfig struct { 1107} 1108 1109func (*awsRestxml_deserializeOpCreateQueryLoggingConfig) ID() string { 1110 return "OperationDeserializer" 1111} 1112 1113func (m *awsRestxml_deserializeOpCreateQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1114 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1115) { 1116 out, metadata, err = next.HandleDeserialize(ctx, in) 1117 if err != nil { 1118 return out, metadata, err 1119 } 1120 1121 response, ok := out.RawResponse.(*smithyhttp.Response) 1122 if !ok { 1123 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1124 } 1125 1126 if response.StatusCode < 200 || response.StatusCode >= 300 { 1127 return out, metadata, awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response, &metadata) 1128 } 1129 output := &CreateQueryLoggingConfigOutput{} 1130 out.Result = output 1131 1132 err = awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(output, response) 1133 if err != nil { 1134 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1135 } 1136 1137 var buff [1024]byte 1138 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1139 body := io.TeeReader(response.Body, ringBuffer) 1140 rootDecoder := xml.NewDecoder(body) 1141 t, err := smithyxml.FetchRootElement(rootDecoder) 1142 if err == io.EOF { 1143 return out, metadata, nil 1144 } 1145 if err != nil { 1146 var snapshot bytes.Buffer 1147 io.Copy(&snapshot, ringBuffer) 1148 return out, metadata, &smithy.DeserializationError{ 1149 Err: fmt.Errorf("failed to decode response body, %w", err), 1150 Snapshot: snapshot.Bytes(), 1151 } 1152 } 1153 1154 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1155 err = awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(&output, decoder) 1156 if err != nil { 1157 var snapshot bytes.Buffer 1158 io.Copy(&snapshot, ringBuffer) 1159 return out, metadata, &smithy.DeserializationError{ 1160 Err: fmt.Errorf("failed to decode response body, %w", err), 1161 Snapshot: snapshot.Bytes(), 1162 } 1163 } 1164 1165 return out, metadata, err 1166} 1167 1168func awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1169 var errorBuffer bytes.Buffer 1170 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1171 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1172 } 1173 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1174 1175 errorCode := "UnknownError" 1176 errorMessage := errorCode 1177 1178 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1179 if err != nil { 1180 return err 1181 } 1182 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1183 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1184 } 1185 if len(errorComponents.Code) != 0 { 1186 errorCode = errorComponents.Code 1187 } 1188 if len(errorComponents.Message) != 0 { 1189 errorMessage = errorComponents.Message 1190 } 1191 errorBody.Seek(0, io.SeekStart) 1192 switch { 1193 case strings.EqualFold("ConcurrentModification", errorCode): 1194 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 1195 1196 case strings.EqualFold("InsufficientCloudWatchLogsResourcePolicy", errorCode): 1197 return awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response, errorBody) 1198 1199 case strings.EqualFold("InvalidInput", errorCode): 1200 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1201 1202 case strings.EqualFold("NoSuchCloudWatchLogsLogGroup", errorCode): 1203 return awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response, errorBody) 1204 1205 case strings.EqualFold("NoSuchHostedZone", errorCode): 1206 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 1207 1208 case strings.EqualFold("QueryLoggingConfigAlreadyExists", errorCode): 1209 return awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response, errorBody) 1210 1211 default: 1212 genericError := &smithy.GenericAPIError{ 1213 Code: errorCode, 1214 Message: errorMessage, 1215 } 1216 return genericError 1217 1218 } 1219} 1220 1221func awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(v *CreateQueryLoggingConfigOutput, response *smithyhttp.Response) error { 1222 if v == nil { 1223 return fmt.Errorf("unsupported deserialization for nil %T", v) 1224 } 1225 1226 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1227 headerValues[0] = strings.TrimSpace(headerValues[0]) 1228 v.Location = ptr.String(headerValues[0]) 1229 } 1230 1231 return nil 1232} 1233func awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(v **CreateQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error { 1234 if v == nil { 1235 return fmt.Errorf("unexpected nil of type %T", v) 1236 } 1237 var sv *CreateQueryLoggingConfigOutput 1238 if *v == nil { 1239 sv = &CreateQueryLoggingConfigOutput{} 1240 } else { 1241 sv = *v 1242 } 1243 1244 for { 1245 t, done, err := decoder.Token() 1246 if err != nil { 1247 return err 1248 } 1249 if done { 1250 break 1251 } 1252 originalDecoder := decoder 1253 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1254 switch { 1255 case strings.EqualFold("QueryLoggingConfig", t.Name.Local): 1256 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1257 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil { 1258 return err 1259 } 1260 1261 default: 1262 // Do nothing and ignore the unexpected tag element 1263 err = decoder.Decoder.Skip() 1264 if err != nil { 1265 return err 1266 } 1267 1268 } 1269 decoder = originalDecoder 1270 } 1271 *v = sv 1272 return nil 1273} 1274 1275type awsRestxml_deserializeOpCreateReusableDelegationSet struct { 1276} 1277 1278func (*awsRestxml_deserializeOpCreateReusableDelegationSet) ID() string { 1279 return "OperationDeserializer" 1280} 1281 1282func (m *awsRestxml_deserializeOpCreateReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1283 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1284) { 1285 out, metadata, err = next.HandleDeserialize(ctx, in) 1286 if err != nil { 1287 return out, metadata, err 1288 } 1289 1290 response, ok := out.RawResponse.(*smithyhttp.Response) 1291 if !ok { 1292 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1293 } 1294 1295 if response.StatusCode < 200 || response.StatusCode >= 300 { 1296 return out, metadata, awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response, &metadata) 1297 } 1298 output := &CreateReusableDelegationSetOutput{} 1299 out.Result = output 1300 1301 err = awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(output, response) 1302 if err != nil { 1303 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1304 } 1305 1306 var buff [1024]byte 1307 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1308 body := io.TeeReader(response.Body, ringBuffer) 1309 rootDecoder := xml.NewDecoder(body) 1310 t, err := smithyxml.FetchRootElement(rootDecoder) 1311 if err == io.EOF { 1312 return out, metadata, nil 1313 } 1314 if err != nil { 1315 var snapshot bytes.Buffer 1316 io.Copy(&snapshot, ringBuffer) 1317 return out, metadata, &smithy.DeserializationError{ 1318 Err: fmt.Errorf("failed to decode response body, %w", err), 1319 Snapshot: snapshot.Bytes(), 1320 } 1321 } 1322 1323 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1324 err = awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(&output, decoder) 1325 if err != nil { 1326 var snapshot bytes.Buffer 1327 io.Copy(&snapshot, ringBuffer) 1328 return out, metadata, &smithy.DeserializationError{ 1329 Err: fmt.Errorf("failed to decode response body, %w", err), 1330 Snapshot: snapshot.Bytes(), 1331 } 1332 } 1333 1334 return out, metadata, err 1335} 1336 1337func awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1338 var errorBuffer bytes.Buffer 1339 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1340 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1341 } 1342 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1343 1344 errorCode := "UnknownError" 1345 errorMessage := errorCode 1346 1347 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1348 if err != nil { 1349 return err 1350 } 1351 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1352 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1353 } 1354 if len(errorComponents.Code) != 0 { 1355 errorCode = errorComponents.Code 1356 } 1357 if len(errorComponents.Message) != 0 { 1358 errorMessage = errorComponents.Message 1359 } 1360 errorBody.Seek(0, io.SeekStart) 1361 switch { 1362 case strings.EqualFold("DelegationSetAlreadyCreated", errorCode): 1363 return awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response, errorBody) 1364 1365 case strings.EqualFold("DelegationSetAlreadyReusable", errorCode): 1366 return awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response, errorBody) 1367 1368 case strings.EqualFold("DelegationSetNotAvailable", errorCode): 1369 return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody) 1370 1371 case strings.EqualFold("HostedZoneNotFound", errorCode): 1372 return awsRestxml_deserializeErrorHostedZoneNotFound(response, errorBody) 1373 1374 case strings.EqualFold("InvalidArgument", errorCode): 1375 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 1376 1377 case strings.EqualFold("InvalidInput", errorCode): 1378 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1379 1380 case strings.EqualFold("LimitsExceeded", errorCode): 1381 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody) 1382 1383 default: 1384 genericError := &smithy.GenericAPIError{ 1385 Code: errorCode, 1386 Message: errorMessage, 1387 } 1388 return genericError 1389 1390 } 1391} 1392 1393func awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(v *CreateReusableDelegationSetOutput, response *smithyhttp.Response) error { 1394 if v == nil { 1395 return fmt.Errorf("unsupported deserialization for nil %T", v) 1396 } 1397 1398 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1399 headerValues[0] = strings.TrimSpace(headerValues[0]) 1400 v.Location = ptr.String(headerValues[0]) 1401 } 1402 1403 return nil 1404} 1405func awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(v **CreateReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error { 1406 if v == nil { 1407 return fmt.Errorf("unexpected nil of type %T", v) 1408 } 1409 var sv *CreateReusableDelegationSetOutput 1410 if *v == nil { 1411 sv = &CreateReusableDelegationSetOutput{} 1412 } else { 1413 sv = *v 1414 } 1415 1416 for { 1417 t, done, err := decoder.Token() 1418 if err != nil { 1419 return err 1420 } 1421 if done { 1422 break 1423 } 1424 originalDecoder := decoder 1425 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1426 switch { 1427 case strings.EqualFold("DelegationSet", t.Name.Local): 1428 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1429 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 1430 return err 1431 } 1432 1433 default: 1434 // Do nothing and ignore the unexpected tag element 1435 err = decoder.Decoder.Skip() 1436 if err != nil { 1437 return err 1438 } 1439 1440 } 1441 decoder = originalDecoder 1442 } 1443 *v = sv 1444 return nil 1445} 1446 1447type awsRestxml_deserializeOpCreateTrafficPolicy struct { 1448} 1449 1450func (*awsRestxml_deserializeOpCreateTrafficPolicy) ID() string { 1451 return "OperationDeserializer" 1452} 1453 1454func (m *awsRestxml_deserializeOpCreateTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1455 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1456) { 1457 out, metadata, err = next.HandleDeserialize(ctx, in) 1458 if err != nil { 1459 return out, metadata, err 1460 } 1461 1462 response, ok := out.RawResponse.(*smithyhttp.Response) 1463 if !ok { 1464 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1465 } 1466 1467 if response.StatusCode < 200 || response.StatusCode >= 300 { 1468 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicy(response, &metadata) 1469 } 1470 output := &CreateTrafficPolicyOutput{} 1471 out.Result = output 1472 1473 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(output, response) 1474 if err != nil { 1475 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1476 } 1477 1478 var buff [1024]byte 1479 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1480 body := io.TeeReader(response.Body, ringBuffer) 1481 rootDecoder := xml.NewDecoder(body) 1482 t, err := smithyxml.FetchRootElement(rootDecoder) 1483 if err == io.EOF { 1484 return out, metadata, nil 1485 } 1486 if err != nil { 1487 var snapshot bytes.Buffer 1488 io.Copy(&snapshot, ringBuffer) 1489 return out, metadata, &smithy.DeserializationError{ 1490 Err: fmt.Errorf("failed to decode response body, %w", err), 1491 Snapshot: snapshot.Bytes(), 1492 } 1493 } 1494 1495 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1496 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(&output, decoder) 1497 if err != nil { 1498 var snapshot bytes.Buffer 1499 io.Copy(&snapshot, ringBuffer) 1500 return out, metadata, &smithy.DeserializationError{ 1501 Err: fmt.Errorf("failed to decode response body, %w", err), 1502 Snapshot: snapshot.Bytes(), 1503 } 1504 } 1505 1506 return out, metadata, err 1507} 1508 1509func awsRestxml_deserializeOpErrorCreateTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1510 var errorBuffer bytes.Buffer 1511 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1512 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1513 } 1514 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1515 1516 errorCode := "UnknownError" 1517 errorMessage := errorCode 1518 1519 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1520 if err != nil { 1521 return err 1522 } 1523 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1524 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1525 } 1526 if len(errorComponents.Code) != 0 { 1527 errorCode = errorComponents.Code 1528 } 1529 if len(errorComponents.Message) != 0 { 1530 errorMessage = errorComponents.Message 1531 } 1532 errorBody.Seek(0, io.SeekStart) 1533 switch { 1534 case strings.EqualFold("InvalidInput", errorCode): 1535 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1536 1537 case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode): 1538 return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody) 1539 1540 case strings.EqualFold("TooManyTrafficPolicies", errorCode): 1541 return awsRestxml_deserializeErrorTooManyTrafficPolicies(response, errorBody) 1542 1543 case strings.EqualFold("TrafficPolicyAlreadyExists", errorCode): 1544 return awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response, errorBody) 1545 1546 default: 1547 genericError := &smithy.GenericAPIError{ 1548 Code: errorCode, 1549 Message: errorMessage, 1550 } 1551 return genericError 1552 1553 } 1554} 1555 1556func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(v *CreateTrafficPolicyOutput, response *smithyhttp.Response) error { 1557 if v == nil { 1558 return fmt.Errorf("unsupported deserialization for nil %T", v) 1559 } 1560 1561 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1562 headerValues[0] = strings.TrimSpace(headerValues[0]) 1563 v.Location = ptr.String(headerValues[0]) 1564 } 1565 1566 return nil 1567} 1568func awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(v **CreateTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error { 1569 if v == nil { 1570 return fmt.Errorf("unexpected nil of type %T", v) 1571 } 1572 var sv *CreateTrafficPolicyOutput 1573 if *v == nil { 1574 sv = &CreateTrafficPolicyOutput{} 1575 } else { 1576 sv = *v 1577 } 1578 1579 for { 1580 t, done, err := decoder.Token() 1581 if err != nil { 1582 return err 1583 } 1584 if done { 1585 break 1586 } 1587 originalDecoder := decoder 1588 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1589 switch { 1590 case strings.EqualFold("TrafficPolicy", t.Name.Local): 1591 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1592 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 1593 return err 1594 } 1595 1596 default: 1597 // Do nothing and ignore the unexpected tag element 1598 err = decoder.Decoder.Skip() 1599 if err != nil { 1600 return err 1601 } 1602 1603 } 1604 decoder = originalDecoder 1605 } 1606 *v = sv 1607 return nil 1608} 1609 1610type awsRestxml_deserializeOpCreateTrafficPolicyInstance struct { 1611} 1612 1613func (*awsRestxml_deserializeOpCreateTrafficPolicyInstance) ID() string { 1614 return "OperationDeserializer" 1615} 1616 1617func (m *awsRestxml_deserializeOpCreateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1619) { 1620 out, metadata, err = next.HandleDeserialize(ctx, in) 1621 if err != nil { 1622 return out, metadata, err 1623 } 1624 1625 response, ok := out.RawResponse.(*smithyhttp.Response) 1626 if !ok { 1627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1628 } 1629 1630 if response.StatusCode < 200 || response.StatusCode >= 300 { 1631 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response, &metadata) 1632 } 1633 output := &CreateTrafficPolicyInstanceOutput{} 1634 out.Result = output 1635 1636 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(output, response) 1637 if err != nil { 1638 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1639 } 1640 1641 var buff [1024]byte 1642 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1643 body := io.TeeReader(response.Body, ringBuffer) 1644 rootDecoder := xml.NewDecoder(body) 1645 t, err := smithyxml.FetchRootElement(rootDecoder) 1646 if err == io.EOF { 1647 return out, metadata, nil 1648 } 1649 if err != nil { 1650 var snapshot bytes.Buffer 1651 io.Copy(&snapshot, ringBuffer) 1652 return out, metadata, &smithy.DeserializationError{ 1653 Err: fmt.Errorf("failed to decode response body, %w", err), 1654 Snapshot: snapshot.Bytes(), 1655 } 1656 } 1657 1658 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1659 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(&output, decoder) 1660 if err != nil { 1661 var snapshot bytes.Buffer 1662 io.Copy(&snapshot, ringBuffer) 1663 return out, metadata, &smithy.DeserializationError{ 1664 Err: fmt.Errorf("failed to decode response body, %w", err), 1665 Snapshot: snapshot.Bytes(), 1666 } 1667 } 1668 1669 return out, metadata, err 1670} 1671 1672func awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1673 var errorBuffer bytes.Buffer 1674 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1675 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1676 } 1677 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1678 1679 errorCode := "UnknownError" 1680 errorMessage := errorCode 1681 1682 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1683 if err != nil { 1684 return err 1685 } 1686 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1687 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1688 } 1689 if len(errorComponents.Code) != 0 { 1690 errorCode = errorComponents.Code 1691 } 1692 if len(errorComponents.Message) != 0 { 1693 errorMessage = errorComponents.Message 1694 } 1695 errorBody.Seek(0, io.SeekStart) 1696 switch { 1697 case strings.EqualFold("InvalidInput", errorCode): 1698 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1699 1700 case strings.EqualFold("NoSuchHostedZone", errorCode): 1701 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 1702 1703 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 1704 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 1705 1706 case strings.EqualFold("TooManyTrafficPolicyInstances", errorCode): 1707 return awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response, errorBody) 1708 1709 case strings.EqualFold("TrafficPolicyInstanceAlreadyExists", errorCode): 1710 return awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response, errorBody) 1711 1712 default: 1713 genericError := &smithy.GenericAPIError{ 1714 Code: errorCode, 1715 Message: errorMessage, 1716 } 1717 return genericError 1718 1719 } 1720} 1721 1722func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(v *CreateTrafficPolicyInstanceOutput, response *smithyhttp.Response) error { 1723 if v == nil { 1724 return fmt.Errorf("unsupported deserialization for nil %T", v) 1725 } 1726 1727 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1728 headerValues[0] = strings.TrimSpace(headerValues[0]) 1729 v.Location = ptr.String(headerValues[0]) 1730 } 1731 1732 return nil 1733} 1734func awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(v **CreateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error { 1735 if v == nil { 1736 return fmt.Errorf("unexpected nil of type %T", v) 1737 } 1738 var sv *CreateTrafficPolicyInstanceOutput 1739 if *v == nil { 1740 sv = &CreateTrafficPolicyInstanceOutput{} 1741 } else { 1742 sv = *v 1743 } 1744 1745 for { 1746 t, done, err := decoder.Token() 1747 if err != nil { 1748 return err 1749 } 1750 if done { 1751 break 1752 } 1753 originalDecoder := decoder 1754 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1755 switch { 1756 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 1757 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1758 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil { 1759 return err 1760 } 1761 1762 default: 1763 // Do nothing and ignore the unexpected tag element 1764 err = decoder.Decoder.Skip() 1765 if err != nil { 1766 return err 1767 } 1768 1769 } 1770 decoder = originalDecoder 1771 } 1772 *v = sv 1773 return nil 1774} 1775 1776type awsRestxml_deserializeOpCreateTrafficPolicyVersion struct { 1777} 1778 1779func (*awsRestxml_deserializeOpCreateTrafficPolicyVersion) ID() string { 1780 return "OperationDeserializer" 1781} 1782 1783func (m *awsRestxml_deserializeOpCreateTrafficPolicyVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1784 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1785) { 1786 out, metadata, err = next.HandleDeserialize(ctx, in) 1787 if err != nil { 1788 return out, metadata, err 1789 } 1790 1791 response, ok := out.RawResponse.(*smithyhttp.Response) 1792 if !ok { 1793 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1794 } 1795 1796 if response.StatusCode < 200 || response.StatusCode >= 300 { 1797 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response, &metadata) 1798 } 1799 output := &CreateTrafficPolicyVersionOutput{} 1800 out.Result = output 1801 1802 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(output, response) 1803 if err != nil { 1804 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1805 } 1806 1807 var buff [1024]byte 1808 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1809 body := io.TeeReader(response.Body, ringBuffer) 1810 rootDecoder := xml.NewDecoder(body) 1811 t, err := smithyxml.FetchRootElement(rootDecoder) 1812 if err == io.EOF { 1813 return out, metadata, nil 1814 } 1815 if err != nil { 1816 var snapshot bytes.Buffer 1817 io.Copy(&snapshot, ringBuffer) 1818 return out, metadata, &smithy.DeserializationError{ 1819 Err: fmt.Errorf("failed to decode response body, %w", err), 1820 Snapshot: snapshot.Bytes(), 1821 } 1822 } 1823 1824 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1825 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(&output, decoder) 1826 if err != nil { 1827 var snapshot bytes.Buffer 1828 io.Copy(&snapshot, ringBuffer) 1829 return out, metadata, &smithy.DeserializationError{ 1830 Err: fmt.Errorf("failed to decode response body, %w", err), 1831 Snapshot: snapshot.Bytes(), 1832 } 1833 } 1834 1835 return out, metadata, err 1836} 1837 1838func awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1839 var errorBuffer bytes.Buffer 1840 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1841 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1842 } 1843 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1844 1845 errorCode := "UnknownError" 1846 errorMessage := errorCode 1847 1848 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1849 if err != nil { 1850 return err 1851 } 1852 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1853 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1854 } 1855 if len(errorComponents.Code) != 0 { 1856 errorCode = errorComponents.Code 1857 } 1858 if len(errorComponents.Message) != 0 { 1859 errorMessage = errorComponents.Message 1860 } 1861 errorBody.Seek(0, io.SeekStart) 1862 switch { 1863 case strings.EqualFold("ConcurrentModification", errorCode): 1864 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 1865 1866 case strings.EqualFold("InvalidInput", errorCode): 1867 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 1868 1869 case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode): 1870 return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody) 1871 1872 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 1873 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 1874 1875 case strings.EqualFold("TooManyTrafficPolicyVersionsForCurrentPolicy", errorCode): 1876 return awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response, errorBody) 1877 1878 default: 1879 genericError := &smithy.GenericAPIError{ 1880 Code: errorCode, 1881 Message: errorMessage, 1882 } 1883 return genericError 1884 1885 } 1886} 1887 1888func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(v *CreateTrafficPolicyVersionOutput, response *smithyhttp.Response) error { 1889 if v == nil { 1890 return fmt.Errorf("unsupported deserialization for nil %T", v) 1891 } 1892 1893 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 1894 headerValues[0] = strings.TrimSpace(headerValues[0]) 1895 v.Location = ptr.String(headerValues[0]) 1896 } 1897 1898 return nil 1899} 1900func awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(v **CreateTrafficPolicyVersionOutput, decoder smithyxml.NodeDecoder) error { 1901 if v == nil { 1902 return fmt.Errorf("unexpected nil of type %T", v) 1903 } 1904 var sv *CreateTrafficPolicyVersionOutput 1905 if *v == nil { 1906 sv = &CreateTrafficPolicyVersionOutput{} 1907 } else { 1908 sv = *v 1909 } 1910 1911 for { 1912 t, done, err := decoder.Token() 1913 if err != nil { 1914 return err 1915 } 1916 if done { 1917 break 1918 } 1919 originalDecoder := decoder 1920 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1921 switch { 1922 case strings.EqualFold("TrafficPolicy", t.Name.Local): 1923 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1924 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 1925 return err 1926 } 1927 1928 default: 1929 // Do nothing and ignore the unexpected tag element 1930 err = decoder.Decoder.Skip() 1931 if err != nil { 1932 return err 1933 } 1934 1935 } 1936 decoder = originalDecoder 1937 } 1938 *v = sv 1939 return nil 1940} 1941 1942type awsRestxml_deserializeOpCreateVPCAssociationAuthorization struct { 1943} 1944 1945func (*awsRestxml_deserializeOpCreateVPCAssociationAuthorization) ID() string { 1946 return "OperationDeserializer" 1947} 1948 1949func (m *awsRestxml_deserializeOpCreateVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1950 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1951) { 1952 out, metadata, err = next.HandleDeserialize(ctx, in) 1953 if err != nil { 1954 return out, metadata, err 1955 } 1956 1957 response, ok := out.RawResponse.(*smithyhttp.Response) 1958 if !ok { 1959 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1960 } 1961 1962 if response.StatusCode < 200 || response.StatusCode >= 300 { 1963 return out, metadata, awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response, &metadata) 1964 } 1965 output := &CreateVPCAssociationAuthorizationOutput{} 1966 out.Result = output 1967 1968 var buff [1024]byte 1969 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1970 body := io.TeeReader(response.Body, ringBuffer) 1971 rootDecoder := xml.NewDecoder(body) 1972 t, err := smithyxml.FetchRootElement(rootDecoder) 1973 if err == io.EOF { 1974 return out, metadata, nil 1975 } 1976 if err != nil { 1977 var snapshot bytes.Buffer 1978 io.Copy(&snapshot, ringBuffer) 1979 return out, metadata, &smithy.DeserializationError{ 1980 Err: fmt.Errorf("failed to decode response body, %w", err), 1981 Snapshot: snapshot.Bytes(), 1982 } 1983 } 1984 1985 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1986 err = awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(&output, decoder) 1987 if err != nil { 1988 var snapshot bytes.Buffer 1989 io.Copy(&snapshot, ringBuffer) 1990 return out, metadata, &smithy.DeserializationError{ 1991 Err: fmt.Errorf("failed to decode response body, %w", err), 1992 Snapshot: snapshot.Bytes(), 1993 } 1994 } 1995 1996 return out, metadata, err 1997} 1998 1999func awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2000 var errorBuffer bytes.Buffer 2001 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2002 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2003 } 2004 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2005 2006 errorCode := "UnknownError" 2007 errorMessage := errorCode 2008 2009 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2010 if err != nil { 2011 return err 2012 } 2013 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2014 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2015 } 2016 if len(errorComponents.Code) != 0 { 2017 errorCode = errorComponents.Code 2018 } 2019 if len(errorComponents.Message) != 0 { 2020 errorMessage = errorComponents.Message 2021 } 2022 errorBody.Seek(0, io.SeekStart) 2023 switch { 2024 case strings.EqualFold("ConcurrentModification", errorCode): 2025 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2026 2027 case strings.EqualFold("InvalidInput", errorCode): 2028 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2029 2030 case strings.EqualFold("InvalidVPCId", errorCode): 2031 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 2032 2033 case strings.EqualFold("NoSuchHostedZone", errorCode): 2034 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 2035 2036 case strings.EqualFold("TooManyVPCAssociationAuthorizations", errorCode): 2037 return awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response, errorBody) 2038 2039 default: 2040 genericError := &smithy.GenericAPIError{ 2041 Code: errorCode, 2042 Message: errorMessage, 2043 } 2044 return genericError 2045 2046 } 2047} 2048 2049func awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(v **CreateVPCAssociationAuthorizationOutput, decoder smithyxml.NodeDecoder) error { 2050 if v == nil { 2051 return fmt.Errorf("unexpected nil of type %T", v) 2052 } 2053 var sv *CreateVPCAssociationAuthorizationOutput 2054 if *v == nil { 2055 sv = &CreateVPCAssociationAuthorizationOutput{} 2056 } else { 2057 sv = *v 2058 } 2059 2060 for { 2061 t, done, err := decoder.Token() 2062 if err != nil { 2063 return err 2064 } 2065 if done { 2066 break 2067 } 2068 originalDecoder := decoder 2069 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2070 switch { 2071 case strings.EqualFold("HostedZoneId", t.Name.Local): 2072 val, err := decoder.Value() 2073 if err != nil { 2074 return err 2075 } 2076 if val == nil { 2077 break 2078 } 2079 { 2080 xtv := string(val) 2081 sv.HostedZoneId = ptr.String(xtv) 2082 } 2083 2084 case strings.EqualFold("VPC", t.Name.Local): 2085 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2086 if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil { 2087 return err 2088 } 2089 2090 default: 2091 // Do nothing and ignore the unexpected tag element 2092 err = decoder.Decoder.Skip() 2093 if err != nil { 2094 return err 2095 } 2096 2097 } 2098 decoder = originalDecoder 2099 } 2100 *v = sv 2101 return nil 2102} 2103 2104type awsRestxml_deserializeOpDeactivateKeySigningKey struct { 2105} 2106 2107func (*awsRestxml_deserializeOpDeactivateKeySigningKey) ID() string { 2108 return "OperationDeserializer" 2109} 2110 2111func (m *awsRestxml_deserializeOpDeactivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2112 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2113) { 2114 out, metadata, err = next.HandleDeserialize(ctx, in) 2115 if err != nil { 2116 return out, metadata, err 2117 } 2118 2119 response, ok := out.RawResponse.(*smithyhttp.Response) 2120 if !ok { 2121 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2122 } 2123 2124 if response.StatusCode < 200 || response.StatusCode >= 300 { 2125 return out, metadata, awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response, &metadata) 2126 } 2127 output := &DeactivateKeySigningKeyOutput{} 2128 out.Result = output 2129 2130 var buff [1024]byte 2131 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2132 body := io.TeeReader(response.Body, ringBuffer) 2133 rootDecoder := xml.NewDecoder(body) 2134 t, err := smithyxml.FetchRootElement(rootDecoder) 2135 if err == io.EOF { 2136 return out, metadata, nil 2137 } 2138 if err != nil { 2139 var snapshot bytes.Buffer 2140 io.Copy(&snapshot, ringBuffer) 2141 return out, metadata, &smithy.DeserializationError{ 2142 Err: fmt.Errorf("failed to decode response body, %w", err), 2143 Snapshot: snapshot.Bytes(), 2144 } 2145 } 2146 2147 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2148 err = awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(&output, decoder) 2149 if err != nil { 2150 var snapshot bytes.Buffer 2151 io.Copy(&snapshot, ringBuffer) 2152 return out, metadata, &smithy.DeserializationError{ 2153 Err: fmt.Errorf("failed to decode response body, %w", err), 2154 Snapshot: snapshot.Bytes(), 2155 } 2156 } 2157 2158 return out, metadata, err 2159} 2160 2161func awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2162 var errorBuffer bytes.Buffer 2163 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2164 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2165 } 2166 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2167 2168 errorCode := "UnknownError" 2169 errorMessage := errorCode 2170 2171 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2172 if err != nil { 2173 return err 2174 } 2175 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2176 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2177 } 2178 if len(errorComponents.Code) != 0 { 2179 errorCode = errorComponents.Code 2180 } 2181 if len(errorComponents.Message) != 0 { 2182 errorMessage = errorComponents.Message 2183 } 2184 errorBody.Seek(0, io.SeekStart) 2185 switch { 2186 case strings.EqualFold("ConcurrentModification", errorCode): 2187 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2188 2189 case strings.EqualFold("InvalidInput", errorCode): 2190 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2191 2192 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 2193 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 2194 2195 case strings.EqualFold("InvalidSigningStatus", errorCode): 2196 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 2197 2198 case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode): 2199 return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody) 2200 2201 case strings.EqualFold("KeySigningKeyInUse", errorCode): 2202 return awsRestxml_deserializeErrorKeySigningKeyInUse(response, errorBody) 2203 2204 case strings.EqualFold("NoSuchKeySigningKey", errorCode): 2205 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody) 2206 2207 default: 2208 genericError := &smithy.GenericAPIError{ 2209 Code: errorCode, 2210 Message: errorMessage, 2211 } 2212 return genericError 2213 2214 } 2215} 2216 2217func awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(v **DeactivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 2218 if v == nil { 2219 return fmt.Errorf("unexpected nil of type %T", v) 2220 } 2221 var sv *DeactivateKeySigningKeyOutput 2222 if *v == nil { 2223 sv = &DeactivateKeySigningKeyOutput{} 2224 } else { 2225 sv = *v 2226 } 2227 2228 for { 2229 t, done, err := decoder.Token() 2230 if err != nil { 2231 return err 2232 } 2233 if done { 2234 break 2235 } 2236 originalDecoder := decoder 2237 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2238 switch { 2239 case strings.EqualFold("ChangeInfo", t.Name.Local): 2240 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2241 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 2242 return err 2243 } 2244 2245 default: 2246 // Do nothing and ignore the unexpected tag element 2247 err = decoder.Decoder.Skip() 2248 if err != nil { 2249 return err 2250 } 2251 2252 } 2253 decoder = originalDecoder 2254 } 2255 *v = sv 2256 return nil 2257} 2258 2259type awsRestxml_deserializeOpDeleteHealthCheck struct { 2260} 2261 2262func (*awsRestxml_deserializeOpDeleteHealthCheck) ID() string { 2263 return "OperationDeserializer" 2264} 2265 2266func (m *awsRestxml_deserializeOpDeleteHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2267 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2268) { 2269 out, metadata, err = next.HandleDeserialize(ctx, in) 2270 if err != nil { 2271 return out, metadata, err 2272 } 2273 2274 response, ok := out.RawResponse.(*smithyhttp.Response) 2275 if !ok { 2276 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2277 } 2278 2279 if response.StatusCode < 200 || response.StatusCode >= 300 { 2280 return out, metadata, awsRestxml_deserializeOpErrorDeleteHealthCheck(response, &metadata) 2281 } 2282 output := &DeleteHealthCheckOutput{} 2283 out.Result = output 2284 2285 return out, metadata, err 2286} 2287 2288func awsRestxml_deserializeOpErrorDeleteHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2289 var errorBuffer bytes.Buffer 2290 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2291 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2292 } 2293 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2294 2295 errorCode := "UnknownError" 2296 errorMessage := errorCode 2297 2298 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2299 if err != nil { 2300 return err 2301 } 2302 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2303 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2304 } 2305 if len(errorComponents.Code) != 0 { 2306 errorCode = errorComponents.Code 2307 } 2308 if len(errorComponents.Message) != 0 { 2309 errorMessage = errorComponents.Message 2310 } 2311 errorBody.Seek(0, io.SeekStart) 2312 switch { 2313 case strings.EqualFold("HealthCheckInUse", errorCode): 2314 return awsRestxml_deserializeErrorHealthCheckInUse(response, errorBody) 2315 2316 case strings.EqualFold("InvalidInput", errorCode): 2317 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2318 2319 case strings.EqualFold("NoSuchHealthCheck", errorCode): 2320 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 2321 2322 default: 2323 genericError := &smithy.GenericAPIError{ 2324 Code: errorCode, 2325 Message: errorMessage, 2326 } 2327 return genericError 2328 2329 } 2330} 2331 2332type awsRestxml_deserializeOpDeleteHostedZone struct { 2333} 2334 2335func (*awsRestxml_deserializeOpDeleteHostedZone) ID() string { 2336 return "OperationDeserializer" 2337} 2338 2339func (m *awsRestxml_deserializeOpDeleteHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2340 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2341) { 2342 out, metadata, err = next.HandleDeserialize(ctx, in) 2343 if err != nil { 2344 return out, metadata, err 2345 } 2346 2347 response, ok := out.RawResponse.(*smithyhttp.Response) 2348 if !ok { 2349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2350 } 2351 2352 if response.StatusCode < 200 || response.StatusCode >= 300 { 2353 return out, metadata, awsRestxml_deserializeOpErrorDeleteHostedZone(response, &metadata) 2354 } 2355 output := &DeleteHostedZoneOutput{} 2356 out.Result = output 2357 2358 var buff [1024]byte 2359 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2360 body := io.TeeReader(response.Body, ringBuffer) 2361 rootDecoder := xml.NewDecoder(body) 2362 t, err := smithyxml.FetchRootElement(rootDecoder) 2363 if err == io.EOF { 2364 return out, metadata, nil 2365 } 2366 if err != nil { 2367 var snapshot bytes.Buffer 2368 io.Copy(&snapshot, ringBuffer) 2369 return out, metadata, &smithy.DeserializationError{ 2370 Err: fmt.Errorf("failed to decode response body, %w", err), 2371 Snapshot: snapshot.Bytes(), 2372 } 2373 } 2374 2375 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2376 err = awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(&output, decoder) 2377 if err != nil { 2378 var snapshot bytes.Buffer 2379 io.Copy(&snapshot, ringBuffer) 2380 return out, metadata, &smithy.DeserializationError{ 2381 Err: fmt.Errorf("failed to decode response body, %w", err), 2382 Snapshot: snapshot.Bytes(), 2383 } 2384 } 2385 2386 return out, metadata, err 2387} 2388 2389func awsRestxml_deserializeOpErrorDeleteHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2390 var errorBuffer bytes.Buffer 2391 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2392 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2393 } 2394 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2395 2396 errorCode := "UnknownError" 2397 errorMessage := errorCode 2398 2399 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2400 if err != nil { 2401 return err 2402 } 2403 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2404 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2405 } 2406 if len(errorComponents.Code) != 0 { 2407 errorCode = errorComponents.Code 2408 } 2409 if len(errorComponents.Message) != 0 { 2410 errorMessage = errorComponents.Message 2411 } 2412 errorBody.Seek(0, io.SeekStart) 2413 switch { 2414 case strings.EqualFold("HostedZoneNotEmpty", errorCode): 2415 return awsRestxml_deserializeErrorHostedZoneNotEmpty(response, errorBody) 2416 2417 case strings.EqualFold("InvalidDomainName", errorCode): 2418 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody) 2419 2420 case strings.EqualFold("InvalidInput", errorCode): 2421 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2422 2423 case strings.EqualFold("NoSuchHostedZone", errorCode): 2424 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 2425 2426 case strings.EqualFold("PriorRequestNotComplete", errorCode): 2427 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 2428 2429 default: 2430 genericError := &smithy.GenericAPIError{ 2431 Code: errorCode, 2432 Message: errorMessage, 2433 } 2434 return genericError 2435 2436 } 2437} 2438 2439func awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(v **DeleteHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 2440 if v == nil { 2441 return fmt.Errorf("unexpected nil of type %T", v) 2442 } 2443 var sv *DeleteHostedZoneOutput 2444 if *v == nil { 2445 sv = &DeleteHostedZoneOutput{} 2446 } else { 2447 sv = *v 2448 } 2449 2450 for { 2451 t, done, err := decoder.Token() 2452 if err != nil { 2453 return err 2454 } 2455 if done { 2456 break 2457 } 2458 originalDecoder := decoder 2459 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2460 switch { 2461 case strings.EqualFold("ChangeInfo", t.Name.Local): 2462 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2463 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 2464 return err 2465 } 2466 2467 default: 2468 // Do nothing and ignore the unexpected tag element 2469 err = decoder.Decoder.Skip() 2470 if err != nil { 2471 return err 2472 } 2473 2474 } 2475 decoder = originalDecoder 2476 } 2477 *v = sv 2478 return nil 2479} 2480 2481type awsRestxml_deserializeOpDeleteKeySigningKey struct { 2482} 2483 2484func (*awsRestxml_deserializeOpDeleteKeySigningKey) ID() string { 2485 return "OperationDeserializer" 2486} 2487 2488func (m *awsRestxml_deserializeOpDeleteKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2489 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2490) { 2491 out, metadata, err = next.HandleDeserialize(ctx, in) 2492 if err != nil { 2493 return out, metadata, err 2494 } 2495 2496 response, ok := out.RawResponse.(*smithyhttp.Response) 2497 if !ok { 2498 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2499 } 2500 2501 if response.StatusCode < 200 || response.StatusCode >= 300 { 2502 return out, metadata, awsRestxml_deserializeOpErrorDeleteKeySigningKey(response, &metadata) 2503 } 2504 output := &DeleteKeySigningKeyOutput{} 2505 out.Result = output 2506 2507 var buff [1024]byte 2508 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2509 body := io.TeeReader(response.Body, ringBuffer) 2510 rootDecoder := xml.NewDecoder(body) 2511 t, err := smithyxml.FetchRootElement(rootDecoder) 2512 if err == io.EOF { 2513 return out, metadata, nil 2514 } 2515 if err != nil { 2516 var snapshot bytes.Buffer 2517 io.Copy(&snapshot, ringBuffer) 2518 return out, metadata, &smithy.DeserializationError{ 2519 Err: fmt.Errorf("failed to decode response body, %w", err), 2520 Snapshot: snapshot.Bytes(), 2521 } 2522 } 2523 2524 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2525 err = awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(&output, decoder) 2526 if err != nil { 2527 var snapshot bytes.Buffer 2528 io.Copy(&snapshot, ringBuffer) 2529 return out, metadata, &smithy.DeserializationError{ 2530 Err: fmt.Errorf("failed to decode response body, %w", err), 2531 Snapshot: snapshot.Bytes(), 2532 } 2533 } 2534 2535 return out, metadata, err 2536} 2537 2538func awsRestxml_deserializeOpErrorDeleteKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2539 var errorBuffer bytes.Buffer 2540 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2541 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2542 } 2543 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2544 2545 errorCode := "UnknownError" 2546 errorMessage := errorCode 2547 2548 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2549 if err != nil { 2550 return err 2551 } 2552 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2553 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2554 } 2555 if len(errorComponents.Code) != 0 { 2556 errorCode = errorComponents.Code 2557 } 2558 if len(errorComponents.Message) != 0 { 2559 errorMessage = errorComponents.Message 2560 } 2561 errorBody.Seek(0, io.SeekStart) 2562 switch { 2563 case strings.EqualFold("ConcurrentModification", errorCode): 2564 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2565 2566 case strings.EqualFold("InvalidInput", errorCode): 2567 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2568 2569 case strings.EqualFold("InvalidKMSArn", errorCode): 2570 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 2571 2572 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 2573 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 2574 2575 case strings.EqualFold("InvalidSigningStatus", errorCode): 2576 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody) 2577 2578 case strings.EqualFold("NoSuchKeySigningKey", errorCode): 2579 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody) 2580 2581 default: 2582 genericError := &smithy.GenericAPIError{ 2583 Code: errorCode, 2584 Message: errorMessage, 2585 } 2586 return genericError 2587 2588 } 2589} 2590 2591func awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(v **DeleteKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error { 2592 if v == nil { 2593 return fmt.Errorf("unexpected nil of type %T", v) 2594 } 2595 var sv *DeleteKeySigningKeyOutput 2596 if *v == nil { 2597 sv = &DeleteKeySigningKeyOutput{} 2598 } else { 2599 sv = *v 2600 } 2601 2602 for { 2603 t, done, err := decoder.Token() 2604 if err != nil { 2605 return err 2606 } 2607 if done { 2608 break 2609 } 2610 originalDecoder := decoder 2611 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2612 switch { 2613 case strings.EqualFold("ChangeInfo", t.Name.Local): 2614 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2615 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 2616 return err 2617 } 2618 2619 default: 2620 // Do nothing and ignore the unexpected tag element 2621 err = decoder.Decoder.Skip() 2622 if err != nil { 2623 return err 2624 } 2625 2626 } 2627 decoder = originalDecoder 2628 } 2629 *v = sv 2630 return nil 2631} 2632 2633type awsRestxml_deserializeOpDeleteQueryLoggingConfig struct { 2634} 2635 2636func (*awsRestxml_deserializeOpDeleteQueryLoggingConfig) ID() string { 2637 return "OperationDeserializer" 2638} 2639 2640func (m *awsRestxml_deserializeOpDeleteQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2641 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2642) { 2643 out, metadata, err = next.HandleDeserialize(ctx, in) 2644 if err != nil { 2645 return out, metadata, err 2646 } 2647 2648 response, ok := out.RawResponse.(*smithyhttp.Response) 2649 if !ok { 2650 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2651 } 2652 2653 if response.StatusCode < 200 || response.StatusCode >= 300 { 2654 return out, metadata, awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response, &metadata) 2655 } 2656 output := &DeleteQueryLoggingConfigOutput{} 2657 out.Result = output 2658 2659 return out, metadata, err 2660} 2661 2662func awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2663 var errorBuffer bytes.Buffer 2664 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2665 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2666 } 2667 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2668 2669 errorCode := "UnknownError" 2670 errorMessage := errorCode 2671 2672 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2673 if err != nil { 2674 return err 2675 } 2676 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2677 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2678 } 2679 if len(errorComponents.Code) != 0 { 2680 errorCode = errorComponents.Code 2681 } 2682 if len(errorComponents.Message) != 0 { 2683 errorMessage = errorComponents.Message 2684 } 2685 errorBody.Seek(0, io.SeekStart) 2686 switch { 2687 case strings.EqualFold("ConcurrentModification", errorCode): 2688 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2689 2690 case strings.EqualFold("InvalidInput", errorCode): 2691 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2692 2693 case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode): 2694 return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody) 2695 2696 default: 2697 genericError := &smithy.GenericAPIError{ 2698 Code: errorCode, 2699 Message: errorMessage, 2700 } 2701 return genericError 2702 2703 } 2704} 2705 2706type awsRestxml_deserializeOpDeleteReusableDelegationSet struct { 2707} 2708 2709func (*awsRestxml_deserializeOpDeleteReusableDelegationSet) ID() string { 2710 return "OperationDeserializer" 2711} 2712 2713func (m *awsRestxml_deserializeOpDeleteReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2714 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2715) { 2716 out, metadata, err = next.HandleDeserialize(ctx, in) 2717 if err != nil { 2718 return out, metadata, err 2719 } 2720 2721 response, ok := out.RawResponse.(*smithyhttp.Response) 2722 if !ok { 2723 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2724 } 2725 2726 if response.StatusCode < 200 || response.StatusCode >= 300 { 2727 return out, metadata, awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response, &metadata) 2728 } 2729 output := &DeleteReusableDelegationSetOutput{} 2730 out.Result = output 2731 2732 return out, metadata, err 2733} 2734 2735func awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2736 var errorBuffer bytes.Buffer 2737 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2738 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2739 } 2740 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2741 2742 errorCode := "UnknownError" 2743 errorMessage := errorCode 2744 2745 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2746 if err != nil { 2747 return err 2748 } 2749 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2750 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2751 } 2752 if len(errorComponents.Code) != 0 { 2753 errorCode = errorComponents.Code 2754 } 2755 if len(errorComponents.Message) != 0 { 2756 errorMessage = errorComponents.Message 2757 } 2758 errorBody.Seek(0, io.SeekStart) 2759 switch { 2760 case strings.EqualFold("DelegationSetInUse", errorCode): 2761 return awsRestxml_deserializeErrorDelegationSetInUse(response, errorBody) 2762 2763 case strings.EqualFold("DelegationSetNotReusable", errorCode): 2764 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 2765 2766 case strings.EqualFold("InvalidInput", errorCode): 2767 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2768 2769 case strings.EqualFold("NoSuchDelegationSet", errorCode): 2770 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 2771 2772 default: 2773 genericError := &smithy.GenericAPIError{ 2774 Code: errorCode, 2775 Message: errorMessage, 2776 } 2777 return genericError 2778 2779 } 2780} 2781 2782type awsRestxml_deserializeOpDeleteTrafficPolicy struct { 2783} 2784 2785func (*awsRestxml_deserializeOpDeleteTrafficPolicy) ID() string { 2786 return "OperationDeserializer" 2787} 2788 2789func (m *awsRestxml_deserializeOpDeleteTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2790 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2791) { 2792 out, metadata, err = next.HandleDeserialize(ctx, in) 2793 if err != nil { 2794 return out, metadata, err 2795 } 2796 2797 response, ok := out.RawResponse.(*smithyhttp.Response) 2798 if !ok { 2799 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2800 } 2801 2802 if response.StatusCode < 200 || response.StatusCode >= 300 { 2803 return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response, &metadata) 2804 } 2805 output := &DeleteTrafficPolicyOutput{} 2806 out.Result = output 2807 2808 return out, metadata, err 2809} 2810 2811func awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2812 var errorBuffer bytes.Buffer 2813 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2814 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2815 } 2816 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2817 2818 errorCode := "UnknownError" 2819 errorMessage := errorCode 2820 2821 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2822 if err != nil { 2823 return err 2824 } 2825 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2826 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2827 } 2828 if len(errorComponents.Code) != 0 { 2829 errorCode = errorComponents.Code 2830 } 2831 if len(errorComponents.Message) != 0 { 2832 errorMessage = errorComponents.Message 2833 } 2834 errorBody.Seek(0, io.SeekStart) 2835 switch { 2836 case strings.EqualFold("ConcurrentModification", errorCode): 2837 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2838 2839 case strings.EqualFold("InvalidInput", errorCode): 2840 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2841 2842 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 2843 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 2844 2845 case strings.EqualFold("TrafficPolicyInUse", errorCode): 2846 return awsRestxml_deserializeErrorTrafficPolicyInUse(response, errorBody) 2847 2848 default: 2849 genericError := &smithy.GenericAPIError{ 2850 Code: errorCode, 2851 Message: errorMessage, 2852 } 2853 return genericError 2854 2855 } 2856} 2857 2858type awsRestxml_deserializeOpDeleteTrafficPolicyInstance struct { 2859} 2860 2861func (*awsRestxml_deserializeOpDeleteTrafficPolicyInstance) ID() string { 2862 return "OperationDeserializer" 2863} 2864 2865func (m *awsRestxml_deserializeOpDeleteTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2866 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2867) { 2868 out, metadata, err = next.HandleDeserialize(ctx, in) 2869 if err != nil { 2870 return out, metadata, err 2871 } 2872 2873 response, ok := out.RawResponse.(*smithyhttp.Response) 2874 if !ok { 2875 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2876 } 2877 2878 if response.StatusCode < 200 || response.StatusCode >= 300 { 2879 return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response, &metadata) 2880 } 2881 output := &DeleteTrafficPolicyInstanceOutput{} 2882 out.Result = output 2883 2884 return out, metadata, err 2885} 2886 2887func awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2888 var errorBuffer bytes.Buffer 2889 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2890 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2891 } 2892 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2893 2894 errorCode := "UnknownError" 2895 errorMessage := errorCode 2896 2897 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2898 if err != nil { 2899 return err 2900 } 2901 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2902 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2903 } 2904 if len(errorComponents.Code) != 0 { 2905 errorCode = errorComponents.Code 2906 } 2907 if len(errorComponents.Message) != 0 { 2908 errorMessage = errorComponents.Message 2909 } 2910 errorBody.Seek(0, io.SeekStart) 2911 switch { 2912 case strings.EqualFold("InvalidInput", errorCode): 2913 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2914 2915 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 2916 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 2917 2918 case strings.EqualFold("PriorRequestNotComplete", errorCode): 2919 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 2920 2921 default: 2922 genericError := &smithy.GenericAPIError{ 2923 Code: errorCode, 2924 Message: errorMessage, 2925 } 2926 return genericError 2927 2928 } 2929} 2930 2931type awsRestxml_deserializeOpDeleteVPCAssociationAuthorization struct { 2932} 2933 2934func (*awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) ID() string { 2935 return "OperationDeserializer" 2936} 2937 2938func (m *awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2939 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2940) { 2941 out, metadata, err = next.HandleDeserialize(ctx, in) 2942 if err != nil { 2943 return out, metadata, err 2944 } 2945 2946 response, ok := out.RawResponse.(*smithyhttp.Response) 2947 if !ok { 2948 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2949 } 2950 2951 if response.StatusCode < 200 || response.StatusCode >= 300 { 2952 return out, metadata, awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response, &metadata) 2953 } 2954 output := &DeleteVPCAssociationAuthorizationOutput{} 2955 out.Result = output 2956 2957 return out, metadata, err 2958} 2959 2960func awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2961 var errorBuffer bytes.Buffer 2962 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2963 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2964 } 2965 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2966 2967 errorCode := "UnknownError" 2968 errorMessage := errorCode 2969 2970 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2971 if err != nil { 2972 return err 2973 } 2974 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2975 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2976 } 2977 if len(errorComponents.Code) != 0 { 2978 errorCode = errorComponents.Code 2979 } 2980 if len(errorComponents.Message) != 0 { 2981 errorMessage = errorComponents.Message 2982 } 2983 errorBody.Seek(0, io.SeekStart) 2984 switch { 2985 case strings.EqualFold("ConcurrentModification", errorCode): 2986 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 2987 2988 case strings.EqualFold("InvalidInput", errorCode): 2989 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 2990 2991 case strings.EqualFold("InvalidVPCId", errorCode): 2992 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 2993 2994 case strings.EqualFold("NoSuchHostedZone", errorCode): 2995 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 2996 2997 case strings.EqualFold("VPCAssociationAuthorizationNotFound", errorCode): 2998 return awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response, errorBody) 2999 3000 default: 3001 genericError := &smithy.GenericAPIError{ 3002 Code: errorCode, 3003 Message: errorMessage, 3004 } 3005 return genericError 3006 3007 } 3008} 3009 3010type awsRestxml_deserializeOpDisableHostedZoneDNSSEC struct { 3011} 3012 3013func (*awsRestxml_deserializeOpDisableHostedZoneDNSSEC) ID() string { 3014 return "OperationDeserializer" 3015} 3016 3017func (m *awsRestxml_deserializeOpDisableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3018 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3019) { 3020 out, metadata, err = next.HandleDeserialize(ctx, in) 3021 if err != nil { 3022 return out, metadata, err 3023 } 3024 3025 response, ok := out.RawResponse.(*smithyhttp.Response) 3026 if !ok { 3027 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3028 } 3029 3030 if response.StatusCode < 200 || response.StatusCode >= 300 { 3031 return out, metadata, awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response, &metadata) 3032 } 3033 output := &DisableHostedZoneDNSSECOutput{} 3034 out.Result = output 3035 3036 var buff [1024]byte 3037 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3038 body := io.TeeReader(response.Body, ringBuffer) 3039 rootDecoder := xml.NewDecoder(body) 3040 t, err := smithyxml.FetchRootElement(rootDecoder) 3041 if err == io.EOF { 3042 return out, metadata, nil 3043 } 3044 if err != nil { 3045 var snapshot bytes.Buffer 3046 io.Copy(&snapshot, ringBuffer) 3047 return out, metadata, &smithy.DeserializationError{ 3048 Err: fmt.Errorf("failed to decode response body, %w", err), 3049 Snapshot: snapshot.Bytes(), 3050 } 3051 } 3052 3053 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3054 err = awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(&output, decoder) 3055 if err != nil { 3056 var snapshot bytes.Buffer 3057 io.Copy(&snapshot, ringBuffer) 3058 return out, metadata, &smithy.DeserializationError{ 3059 Err: fmt.Errorf("failed to decode response body, %w", err), 3060 Snapshot: snapshot.Bytes(), 3061 } 3062 } 3063 3064 return out, metadata, err 3065} 3066 3067func awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3068 var errorBuffer bytes.Buffer 3069 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3070 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3071 } 3072 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3073 3074 errorCode := "UnknownError" 3075 errorMessage := errorCode 3076 3077 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3078 if err != nil { 3079 return err 3080 } 3081 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3082 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3083 } 3084 if len(errorComponents.Code) != 0 { 3085 errorCode = errorComponents.Code 3086 } 3087 if len(errorComponents.Message) != 0 { 3088 errorMessage = errorComponents.Message 3089 } 3090 errorBody.Seek(0, io.SeekStart) 3091 switch { 3092 case strings.EqualFold("ConcurrentModification", errorCode): 3093 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 3094 3095 case strings.EqualFold("DNSSECNotFound", errorCode): 3096 return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody) 3097 3098 case strings.EqualFold("InvalidArgument", errorCode): 3099 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 3100 3101 case strings.EqualFold("InvalidInput", errorCode): 3102 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3103 3104 case strings.EqualFold("InvalidKMSArn", errorCode): 3105 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 3106 3107 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 3108 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 3109 3110 case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode): 3111 return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody) 3112 3113 case strings.EqualFold("NoSuchHostedZone", errorCode): 3114 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3115 3116 default: 3117 genericError := &smithy.GenericAPIError{ 3118 Code: errorCode, 3119 Message: errorMessage, 3120 } 3121 return genericError 3122 3123 } 3124} 3125 3126func awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(v **DisableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error { 3127 if v == nil { 3128 return fmt.Errorf("unexpected nil of type %T", v) 3129 } 3130 var sv *DisableHostedZoneDNSSECOutput 3131 if *v == nil { 3132 sv = &DisableHostedZoneDNSSECOutput{} 3133 } else { 3134 sv = *v 3135 } 3136 3137 for { 3138 t, done, err := decoder.Token() 3139 if err != nil { 3140 return err 3141 } 3142 if done { 3143 break 3144 } 3145 originalDecoder := decoder 3146 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3147 switch { 3148 case strings.EqualFold("ChangeInfo", t.Name.Local): 3149 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3150 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3151 return err 3152 } 3153 3154 default: 3155 // Do nothing and ignore the unexpected tag element 3156 err = decoder.Decoder.Skip() 3157 if err != nil { 3158 return err 3159 } 3160 3161 } 3162 decoder = originalDecoder 3163 } 3164 *v = sv 3165 return nil 3166} 3167 3168type awsRestxml_deserializeOpDisassociateVPCFromHostedZone struct { 3169} 3170 3171func (*awsRestxml_deserializeOpDisassociateVPCFromHostedZone) ID() string { 3172 return "OperationDeserializer" 3173} 3174 3175func (m *awsRestxml_deserializeOpDisassociateVPCFromHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3176 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3177) { 3178 out, metadata, err = next.HandleDeserialize(ctx, in) 3179 if err != nil { 3180 return out, metadata, err 3181 } 3182 3183 response, ok := out.RawResponse.(*smithyhttp.Response) 3184 if !ok { 3185 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3186 } 3187 3188 if response.StatusCode < 200 || response.StatusCode >= 300 { 3189 return out, metadata, awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response, &metadata) 3190 } 3191 output := &DisassociateVPCFromHostedZoneOutput{} 3192 out.Result = output 3193 3194 var buff [1024]byte 3195 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3196 body := io.TeeReader(response.Body, ringBuffer) 3197 rootDecoder := xml.NewDecoder(body) 3198 t, err := smithyxml.FetchRootElement(rootDecoder) 3199 if err == io.EOF { 3200 return out, metadata, nil 3201 } 3202 if err != nil { 3203 var snapshot bytes.Buffer 3204 io.Copy(&snapshot, ringBuffer) 3205 return out, metadata, &smithy.DeserializationError{ 3206 Err: fmt.Errorf("failed to decode response body, %w", err), 3207 Snapshot: snapshot.Bytes(), 3208 } 3209 } 3210 3211 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3212 err = awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(&output, decoder) 3213 if err != nil { 3214 var snapshot bytes.Buffer 3215 io.Copy(&snapshot, ringBuffer) 3216 return out, metadata, &smithy.DeserializationError{ 3217 Err: fmt.Errorf("failed to decode response body, %w", err), 3218 Snapshot: snapshot.Bytes(), 3219 } 3220 } 3221 3222 return out, metadata, err 3223} 3224 3225func awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3226 var errorBuffer bytes.Buffer 3227 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3228 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3229 } 3230 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3231 3232 errorCode := "UnknownError" 3233 errorMessage := errorCode 3234 3235 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3236 if err != nil { 3237 return err 3238 } 3239 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3240 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3241 } 3242 if len(errorComponents.Code) != 0 { 3243 errorCode = errorComponents.Code 3244 } 3245 if len(errorComponents.Message) != 0 { 3246 errorMessage = errorComponents.Message 3247 } 3248 errorBody.Seek(0, io.SeekStart) 3249 switch { 3250 case strings.EqualFold("InvalidInput", errorCode): 3251 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3252 3253 case strings.EqualFold("InvalidVPCId", errorCode): 3254 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody) 3255 3256 case strings.EqualFold("LastVPCAssociation", errorCode): 3257 return awsRestxml_deserializeErrorLastVPCAssociation(response, errorBody) 3258 3259 case strings.EqualFold("NoSuchHostedZone", errorCode): 3260 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3261 3262 case strings.EqualFold("VPCAssociationNotFound", errorCode): 3263 return awsRestxml_deserializeErrorVPCAssociationNotFound(response, errorBody) 3264 3265 default: 3266 genericError := &smithy.GenericAPIError{ 3267 Code: errorCode, 3268 Message: errorMessage, 3269 } 3270 return genericError 3271 3272 } 3273} 3274 3275func awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(v **DisassociateVPCFromHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 3276 if v == nil { 3277 return fmt.Errorf("unexpected nil of type %T", v) 3278 } 3279 var sv *DisassociateVPCFromHostedZoneOutput 3280 if *v == nil { 3281 sv = &DisassociateVPCFromHostedZoneOutput{} 3282 } else { 3283 sv = *v 3284 } 3285 3286 for { 3287 t, done, err := decoder.Token() 3288 if err != nil { 3289 return err 3290 } 3291 if done { 3292 break 3293 } 3294 originalDecoder := decoder 3295 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3296 switch { 3297 case strings.EqualFold("ChangeInfo", t.Name.Local): 3298 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3299 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3300 return err 3301 } 3302 3303 default: 3304 // Do nothing and ignore the unexpected tag element 3305 err = decoder.Decoder.Skip() 3306 if err != nil { 3307 return err 3308 } 3309 3310 } 3311 decoder = originalDecoder 3312 } 3313 *v = sv 3314 return nil 3315} 3316 3317type awsRestxml_deserializeOpEnableHostedZoneDNSSEC struct { 3318} 3319 3320func (*awsRestxml_deserializeOpEnableHostedZoneDNSSEC) ID() string { 3321 return "OperationDeserializer" 3322} 3323 3324func (m *awsRestxml_deserializeOpEnableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3325 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3326) { 3327 out, metadata, err = next.HandleDeserialize(ctx, in) 3328 if err != nil { 3329 return out, metadata, err 3330 } 3331 3332 response, ok := out.RawResponse.(*smithyhttp.Response) 3333 if !ok { 3334 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3335 } 3336 3337 if response.StatusCode < 200 || response.StatusCode >= 300 { 3338 return out, metadata, awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response, &metadata) 3339 } 3340 output := &EnableHostedZoneDNSSECOutput{} 3341 out.Result = output 3342 3343 var buff [1024]byte 3344 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3345 body := io.TeeReader(response.Body, ringBuffer) 3346 rootDecoder := xml.NewDecoder(body) 3347 t, err := smithyxml.FetchRootElement(rootDecoder) 3348 if err == io.EOF { 3349 return out, metadata, nil 3350 } 3351 if err != nil { 3352 var snapshot bytes.Buffer 3353 io.Copy(&snapshot, ringBuffer) 3354 return out, metadata, &smithy.DeserializationError{ 3355 Err: fmt.Errorf("failed to decode response body, %w", err), 3356 Snapshot: snapshot.Bytes(), 3357 } 3358 } 3359 3360 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3361 err = awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(&output, decoder) 3362 if err != nil { 3363 var snapshot bytes.Buffer 3364 io.Copy(&snapshot, ringBuffer) 3365 return out, metadata, &smithy.DeserializationError{ 3366 Err: fmt.Errorf("failed to decode response body, %w", err), 3367 Snapshot: snapshot.Bytes(), 3368 } 3369 } 3370 3371 return out, metadata, err 3372} 3373 3374func awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3375 var errorBuffer bytes.Buffer 3376 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3377 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3378 } 3379 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3380 3381 errorCode := "UnknownError" 3382 errorMessage := errorCode 3383 3384 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3385 if err != nil { 3386 return err 3387 } 3388 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3389 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3390 } 3391 if len(errorComponents.Code) != 0 { 3392 errorCode = errorComponents.Code 3393 } 3394 if len(errorComponents.Message) != 0 { 3395 errorMessage = errorComponents.Message 3396 } 3397 errorBody.Seek(0, io.SeekStart) 3398 switch { 3399 case strings.EqualFold("ConcurrentModification", errorCode): 3400 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 3401 3402 case strings.EqualFold("DNSSECNotFound", errorCode): 3403 return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody) 3404 3405 case strings.EqualFold("HostedZonePartiallyDelegated", errorCode): 3406 return awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response, errorBody) 3407 3408 case strings.EqualFold("InvalidArgument", errorCode): 3409 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 3410 3411 case strings.EqualFold("InvalidInput", errorCode): 3412 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3413 3414 case strings.EqualFold("InvalidKMSArn", errorCode): 3415 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody) 3416 3417 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode): 3418 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody) 3419 3420 case strings.EqualFold("KeySigningKeyWithActiveStatusNotFound", errorCode): 3421 return awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response, errorBody) 3422 3423 case strings.EqualFold("NoSuchHostedZone", errorCode): 3424 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3425 3426 default: 3427 genericError := &smithy.GenericAPIError{ 3428 Code: errorCode, 3429 Message: errorMessage, 3430 } 3431 return genericError 3432 3433 } 3434} 3435 3436func awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(v **EnableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error { 3437 if v == nil { 3438 return fmt.Errorf("unexpected nil of type %T", v) 3439 } 3440 var sv *EnableHostedZoneDNSSECOutput 3441 if *v == nil { 3442 sv = &EnableHostedZoneDNSSECOutput{} 3443 } else { 3444 sv = *v 3445 } 3446 3447 for { 3448 t, done, err := decoder.Token() 3449 if err != nil { 3450 return err 3451 } 3452 if done { 3453 break 3454 } 3455 originalDecoder := decoder 3456 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3457 switch { 3458 case strings.EqualFold("ChangeInfo", t.Name.Local): 3459 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3460 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3461 return err 3462 } 3463 3464 default: 3465 // Do nothing and ignore the unexpected tag element 3466 err = decoder.Decoder.Skip() 3467 if err != nil { 3468 return err 3469 } 3470 3471 } 3472 decoder = originalDecoder 3473 } 3474 *v = sv 3475 return nil 3476} 3477 3478type awsRestxml_deserializeOpGetAccountLimit struct { 3479} 3480 3481func (*awsRestxml_deserializeOpGetAccountLimit) ID() string { 3482 return "OperationDeserializer" 3483} 3484 3485func (m *awsRestxml_deserializeOpGetAccountLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3486 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3487) { 3488 out, metadata, err = next.HandleDeserialize(ctx, in) 3489 if err != nil { 3490 return out, metadata, err 3491 } 3492 3493 response, ok := out.RawResponse.(*smithyhttp.Response) 3494 if !ok { 3495 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3496 } 3497 3498 if response.StatusCode < 200 || response.StatusCode >= 300 { 3499 return out, metadata, awsRestxml_deserializeOpErrorGetAccountLimit(response, &metadata) 3500 } 3501 output := &GetAccountLimitOutput{} 3502 out.Result = output 3503 3504 var buff [1024]byte 3505 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3506 body := io.TeeReader(response.Body, ringBuffer) 3507 rootDecoder := xml.NewDecoder(body) 3508 t, err := smithyxml.FetchRootElement(rootDecoder) 3509 if err == io.EOF { 3510 return out, metadata, nil 3511 } 3512 if err != nil { 3513 var snapshot bytes.Buffer 3514 io.Copy(&snapshot, ringBuffer) 3515 return out, metadata, &smithy.DeserializationError{ 3516 Err: fmt.Errorf("failed to decode response body, %w", err), 3517 Snapshot: snapshot.Bytes(), 3518 } 3519 } 3520 3521 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3522 err = awsRestxml_deserializeOpDocumentGetAccountLimitOutput(&output, decoder) 3523 if err != nil { 3524 var snapshot bytes.Buffer 3525 io.Copy(&snapshot, ringBuffer) 3526 return out, metadata, &smithy.DeserializationError{ 3527 Err: fmt.Errorf("failed to decode response body, %w", err), 3528 Snapshot: snapshot.Bytes(), 3529 } 3530 } 3531 3532 return out, metadata, err 3533} 3534 3535func awsRestxml_deserializeOpErrorGetAccountLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3536 var errorBuffer bytes.Buffer 3537 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3538 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3539 } 3540 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3541 3542 errorCode := "UnknownError" 3543 errorMessage := errorCode 3544 3545 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3546 if err != nil { 3547 return err 3548 } 3549 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3550 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3551 } 3552 if len(errorComponents.Code) != 0 { 3553 errorCode = errorComponents.Code 3554 } 3555 if len(errorComponents.Message) != 0 { 3556 errorMessage = errorComponents.Message 3557 } 3558 errorBody.Seek(0, io.SeekStart) 3559 switch { 3560 case strings.EqualFold("InvalidInput", errorCode): 3561 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3562 3563 default: 3564 genericError := &smithy.GenericAPIError{ 3565 Code: errorCode, 3566 Message: errorMessage, 3567 } 3568 return genericError 3569 3570 } 3571} 3572 3573func awsRestxml_deserializeOpDocumentGetAccountLimitOutput(v **GetAccountLimitOutput, decoder smithyxml.NodeDecoder) error { 3574 if v == nil { 3575 return fmt.Errorf("unexpected nil of type %T", v) 3576 } 3577 var sv *GetAccountLimitOutput 3578 if *v == nil { 3579 sv = &GetAccountLimitOutput{} 3580 } else { 3581 sv = *v 3582 } 3583 3584 for { 3585 t, done, err := decoder.Token() 3586 if err != nil { 3587 return err 3588 } 3589 if done { 3590 break 3591 } 3592 originalDecoder := decoder 3593 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3594 switch { 3595 case strings.EqualFold("Count", t.Name.Local): 3596 val, err := decoder.Value() 3597 if err != nil { 3598 return err 3599 } 3600 if val == nil { 3601 break 3602 } 3603 { 3604 xtv := string(val) 3605 i64, err := strconv.ParseInt(xtv, 10, 64) 3606 if err != nil { 3607 return err 3608 } 3609 sv.Count = i64 3610 } 3611 3612 case strings.EqualFold("Limit", t.Name.Local): 3613 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3614 if err := awsRestxml_deserializeDocumentAccountLimit(&sv.Limit, nodeDecoder); err != nil { 3615 return err 3616 } 3617 3618 default: 3619 // Do nothing and ignore the unexpected tag element 3620 err = decoder.Decoder.Skip() 3621 if err != nil { 3622 return err 3623 } 3624 3625 } 3626 decoder = originalDecoder 3627 } 3628 *v = sv 3629 return nil 3630} 3631 3632type awsRestxml_deserializeOpGetChange struct { 3633} 3634 3635func (*awsRestxml_deserializeOpGetChange) ID() string { 3636 return "OperationDeserializer" 3637} 3638 3639func (m *awsRestxml_deserializeOpGetChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3640 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3641) { 3642 out, metadata, err = next.HandleDeserialize(ctx, in) 3643 if err != nil { 3644 return out, metadata, err 3645 } 3646 3647 response, ok := out.RawResponse.(*smithyhttp.Response) 3648 if !ok { 3649 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3650 } 3651 3652 if response.StatusCode < 200 || response.StatusCode >= 300 { 3653 return out, metadata, awsRestxml_deserializeOpErrorGetChange(response, &metadata) 3654 } 3655 output := &GetChangeOutput{} 3656 out.Result = output 3657 3658 var buff [1024]byte 3659 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3660 body := io.TeeReader(response.Body, ringBuffer) 3661 rootDecoder := xml.NewDecoder(body) 3662 t, err := smithyxml.FetchRootElement(rootDecoder) 3663 if err == io.EOF { 3664 return out, metadata, nil 3665 } 3666 if err != nil { 3667 var snapshot bytes.Buffer 3668 io.Copy(&snapshot, ringBuffer) 3669 return out, metadata, &smithy.DeserializationError{ 3670 Err: fmt.Errorf("failed to decode response body, %w", err), 3671 Snapshot: snapshot.Bytes(), 3672 } 3673 } 3674 3675 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3676 err = awsRestxml_deserializeOpDocumentGetChangeOutput(&output, decoder) 3677 if err != nil { 3678 var snapshot bytes.Buffer 3679 io.Copy(&snapshot, ringBuffer) 3680 return out, metadata, &smithy.DeserializationError{ 3681 Err: fmt.Errorf("failed to decode response body, %w", err), 3682 Snapshot: snapshot.Bytes(), 3683 } 3684 } 3685 3686 return out, metadata, err 3687} 3688 3689func awsRestxml_deserializeOpErrorGetChange(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3690 var errorBuffer bytes.Buffer 3691 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3692 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3693 } 3694 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3695 3696 errorCode := "UnknownError" 3697 errorMessage := errorCode 3698 3699 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3700 if err != nil { 3701 return err 3702 } 3703 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3704 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3705 } 3706 if len(errorComponents.Code) != 0 { 3707 errorCode = errorComponents.Code 3708 } 3709 if len(errorComponents.Message) != 0 { 3710 errorMessage = errorComponents.Message 3711 } 3712 errorBody.Seek(0, io.SeekStart) 3713 switch { 3714 case strings.EqualFold("InvalidInput", errorCode): 3715 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3716 3717 case strings.EqualFold("NoSuchChange", errorCode): 3718 return awsRestxml_deserializeErrorNoSuchChange(response, errorBody) 3719 3720 default: 3721 genericError := &smithy.GenericAPIError{ 3722 Code: errorCode, 3723 Message: errorMessage, 3724 } 3725 return genericError 3726 3727 } 3728} 3729 3730func awsRestxml_deserializeOpDocumentGetChangeOutput(v **GetChangeOutput, decoder smithyxml.NodeDecoder) error { 3731 if v == nil { 3732 return fmt.Errorf("unexpected nil of type %T", v) 3733 } 3734 var sv *GetChangeOutput 3735 if *v == nil { 3736 sv = &GetChangeOutput{} 3737 } else { 3738 sv = *v 3739 } 3740 3741 for { 3742 t, done, err := decoder.Token() 3743 if err != nil { 3744 return err 3745 } 3746 if done { 3747 break 3748 } 3749 originalDecoder := decoder 3750 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3751 switch { 3752 case strings.EqualFold("ChangeInfo", t.Name.Local): 3753 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3754 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil { 3755 return err 3756 } 3757 3758 default: 3759 // Do nothing and ignore the unexpected tag element 3760 err = decoder.Decoder.Skip() 3761 if err != nil { 3762 return err 3763 } 3764 3765 } 3766 decoder = originalDecoder 3767 } 3768 *v = sv 3769 return nil 3770} 3771 3772type awsRestxml_deserializeOpGetCheckerIpRanges struct { 3773} 3774 3775func (*awsRestxml_deserializeOpGetCheckerIpRanges) ID() string { 3776 return "OperationDeserializer" 3777} 3778 3779func (m *awsRestxml_deserializeOpGetCheckerIpRanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3780 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3781) { 3782 out, metadata, err = next.HandleDeserialize(ctx, in) 3783 if err != nil { 3784 return out, metadata, err 3785 } 3786 3787 response, ok := out.RawResponse.(*smithyhttp.Response) 3788 if !ok { 3789 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3790 } 3791 3792 if response.StatusCode < 200 || response.StatusCode >= 300 { 3793 return out, metadata, awsRestxml_deserializeOpErrorGetCheckerIpRanges(response, &metadata) 3794 } 3795 output := &GetCheckerIpRangesOutput{} 3796 out.Result = output 3797 3798 var buff [1024]byte 3799 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3800 body := io.TeeReader(response.Body, ringBuffer) 3801 rootDecoder := xml.NewDecoder(body) 3802 t, err := smithyxml.FetchRootElement(rootDecoder) 3803 if err == io.EOF { 3804 return out, metadata, nil 3805 } 3806 if err != nil { 3807 var snapshot bytes.Buffer 3808 io.Copy(&snapshot, ringBuffer) 3809 return out, metadata, &smithy.DeserializationError{ 3810 Err: fmt.Errorf("failed to decode response body, %w", err), 3811 Snapshot: snapshot.Bytes(), 3812 } 3813 } 3814 3815 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3816 err = awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(&output, decoder) 3817 if err != nil { 3818 var snapshot bytes.Buffer 3819 io.Copy(&snapshot, ringBuffer) 3820 return out, metadata, &smithy.DeserializationError{ 3821 Err: fmt.Errorf("failed to decode response body, %w", err), 3822 Snapshot: snapshot.Bytes(), 3823 } 3824 } 3825 3826 return out, metadata, err 3827} 3828 3829func awsRestxml_deserializeOpErrorGetCheckerIpRanges(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3830 var errorBuffer bytes.Buffer 3831 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3832 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3833 } 3834 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3835 3836 errorCode := "UnknownError" 3837 errorMessage := errorCode 3838 3839 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3840 if err != nil { 3841 return err 3842 } 3843 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3844 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3845 } 3846 if len(errorComponents.Code) != 0 { 3847 errorCode = errorComponents.Code 3848 } 3849 if len(errorComponents.Message) != 0 { 3850 errorMessage = errorComponents.Message 3851 } 3852 errorBody.Seek(0, io.SeekStart) 3853 switch { 3854 default: 3855 genericError := &smithy.GenericAPIError{ 3856 Code: errorCode, 3857 Message: errorMessage, 3858 } 3859 return genericError 3860 3861 } 3862} 3863 3864func awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(v **GetCheckerIpRangesOutput, decoder smithyxml.NodeDecoder) error { 3865 if v == nil { 3866 return fmt.Errorf("unexpected nil of type %T", v) 3867 } 3868 var sv *GetCheckerIpRangesOutput 3869 if *v == nil { 3870 sv = &GetCheckerIpRangesOutput{} 3871 } else { 3872 sv = *v 3873 } 3874 3875 for { 3876 t, done, err := decoder.Token() 3877 if err != nil { 3878 return err 3879 } 3880 if done { 3881 break 3882 } 3883 originalDecoder := decoder 3884 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3885 switch { 3886 case strings.EqualFold("CheckerIpRanges", t.Name.Local): 3887 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3888 if err := awsRestxml_deserializeDocumentCheckerIpRanges(&sv.CheckerIpRanges, nodeDecoder); err != nil { 3889 return err 3890 } 3891 3892 default: 3893 // Do nothing and ignore the unexpected tag element 3894 err = decoder.Decoder.Skip() 3895 if err != nil { 3896 return err 3897 } 3898 3899 } 3900 decoder = originalDecoder 3901 } 3902 *v = sv 3903 return nil 3904} 3905 3906type awsRestxml_deserializeOpGetDNSSEC struct { 3907} 3908 3909func (*awsRestxml_deserializeOpGetDNSSEC) ID() string { 3910 return "OperationDeserializer" 3911} 3912 3913func (m *awsRestxml_deserializeOpGetDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3914 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3915) { 3916 out, metadata, err = next.HandleDeserialize(ctx, in) 3917 if err != nil { 3918 return out, metadata, err 3919 } 3920 3921 response, ok := out.RawResponse.(*smithyhttp.Response) 3922 if !ok { 3923 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3924 } 3925 3926 if response.StatusCode < 200 || response.StatusCode >= 300 { 3927 return out, metadata, awsRestxml_deserializeOpErrorGetDNSSEC(response, &metadata) 3928 } 3929 output := &GetDNSSECOutput{} 3930 out.Result = output 3931 3932 var buff [1024]byte 3933 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3934 body := io.TeeReader(response.Body, ringBuffer) 3935 rootDecoder := xml.NewDecoder(body) 3936 t, err := smithyxml.FetchRootElement(rootDecoder) 3937 if err == io.EOF { 3938 return out, metadata, nil 3939 } 3940 if err != nil { 3941 var snapshot bytes.Buffer 3942 io.Copy(&snapshot, ringBuffer) 3943 return out, metadata, &smithy.DeserializationError{ 3944 Err: fmt.Errorf("failed to decode response body, %w", err), 3945 Snapshot: snapshot.Bytes(), 3946 } 3947 } 3948 3949 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3950 err = awsRestxml_deserializeOpDocumentGetDNSSECOutput(&output, decoder) 3951 if err != nil { 3952 var snapshot bytes.Buffer 3953 io.Copy(&snapshot, ringBuffer) 3954 return out, metadata, &smithy.DeserializationError{ 3955 Err: fmt.Errorf("failed to decode response body, %w", err), 3956 Snapshot: snapshot.Bytes(), 3957 } 3958 } 3959 3960 return out, metadata, err 3961} 3962 3963func awsRestxml_deserializeOpErrorGetDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3964 var errorBuffer bytes.Buffer 3965 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3966 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3967 } 3968 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3969 3970 errorCode := "UnknownError" 3971 errorMessage := errorCode 3972 3973 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3974 if err != nil { 3975 return err 3976 } 3977 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3978 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3979 } 3980 if len(errorComponents.Code) != 0 { 3981 errorCode = errorComponents.Code 3982 } 3983 if len(errorComponents.Message) != 0 { 3984 errorMessage = errorComponents.Message 3985 } 3986 errorBody.Seek(0, io.SeekStart) 3987 switch { 3988 case strings.EqualFold("InvalidArgument", errorCode): 3989 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody) 3990 3991 case strings.EqualFold("InvalidInput", errorCode): 3992 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 3993 3994 case strings.EqualFold("NoSuchHostedZone", errorCode): 3995 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 3996 3997 default: 3998 genericError := &smithy.GenericAPIError{ 3999 Code: errorCode, 4000 Message: errorMessage, 4001 } 4002 return genericError 4003 4004 } 4005} 4006 4007func awsRestxml_deserializeOpDocumentGetDNSSECOutput(v **GetDNSSECOutput, decoder smithyxml.NodeDecoder) error { 4008 if v == nil { 4009 return fmt.Errorf("unexpected nil of type %T", v) 4010 } 4011 var sv *GetDNSSECOutput 4012 if *v == nil { 4013 sv = &GetDNSSECOutput{} 4014 } else { 4015 sv = *v 4016 } 4017 4018 for { 4019 t, done, err := decoder.Token() 4020 if err != nil { 4021 return err 4022 } 4023 if done { 4024 break 4025 } 4026 originalDecoder := decoder 4027 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4028 switch { 4029 case strings.EqualFold("KeySigningKeys", t.Name.Local): 4030 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4031 if err := awsRestxml_deserializeDocumentKeySigningKeys(&sv.KeySigningKeys, nodeDecoder); err != nil { 4032 return err 4033 } 4034 4035 case strings.EqualFold("Status", t.Name.Local): 4036 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4037 if err := awsRestxml_deserializeDocumentDNSSECStatus(&sv.Status, nodeDecoder); err != nil { 4038 return err 4039 } 4040 4041 default: 4042 // Do nothing and ignore the unexpected tag element 4043 err = decoder.Decoder.Skip() 4044 if err != nil { 4045 return err 4046 } 4047 4048 } 4049 decoder = originalDecoder 4050 } 4051 *v = sv 4052 return nil 4053} 4054 4055type awsRestxml_deserializeOpGetGeoLocation struct { 4056} 4057 4058func (*awsRestxml_deserializeOpGetGeoLocation) ID() string { 4059 return "OperationDeserializer" 4060} 4061 4062func (m *awsRestxml_deserializeOpGetGeoLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4063 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4064) { 4065 out, metadata, err = next.HandleDeserialize(ctx, in) 4066 if err != nil { 4067 return out, metadata, err 4068 } 4069 4070 response, ok := out.RawResponse.(*smithyhttp.Response) 4071 if !ok { 4072 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4073 } 4074 4075 if response.StatusCode < 200 || response.StatusCode >= 300 { 4076 return out, metadata, awsRestxml_deserializeOpErrorGetGeoLocation(response, &metadata) 4077 } 4078 output := &GetGeoLocationOutput{} 4079 out.Result = output 4080 4081 var buff [1024]byte 4082 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4083 body := io.TeeReader(response.Body, ringBuffer) 4084 rootDecoder := xml.NewDecoder(body) 4085 t, err := smithyxml.FetchRootElement(rootDecoder) 4086 if err == io.EOF { 4087 return out, metadata, nil 4088 } 4089 if err != nil { 4090 var snapshot bytes.Buffer 4091 io.Copy(&snapshot, ringBuffer) 4092 return out, metadata, &smithy.DeserializationError{ 4093 Err: fmt.Errorf("failed to decode response body, %w", err), 4094 Snapshot: snapshot.Bytes(), 4095 } 4096 } 4097 4098 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4099 err = awsRestxml_deserializeOpDocumentGetGeoLocationOutput(&output, decoder) 4100 if err != nil { 4101 var snapshot bytes.Buffer 4102 io.Copy(&snapshot, ringBuffer) 4103 return out, metadata, &smithy.DeserializationError{ 4104 Err: fmt.Errorf("failed to decode response body, %w", err), 4105 Snapshot: snapshot.Bytes(), 4106 } 4107 } 4108 4109 return out, metadata, err 4110} 4111 4112func awsRestxml_deserializeOpErrorGetGeoLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4113 var errorBuffer bytes.Buffer 4114 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4115 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4116 } 4117 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4118 4119 errorCode := "UnknownError" 4120 errorMessage := errorCode 4121 4122 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4123 if err != nil { 4124 return err 4125 } 4126 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4127 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4128 } 4129 if len(errorComponents.Code) != 0 { 4130 errorCode = errorComponents.Code 4131 } 4132 if len(errorComponents.Message) != 0 { 4133 errorMessage = errorComponents.Message 4134 } 4135 errorBody.Seek(0, io.SeekStart) 4136 switch { 4137 case strings.EqualFold("InvalidInput", errorCode): 4138 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4139 4140 case strings.EqualFold("NoSuchGeoLocation", errorCode): 4141 return awsRestxml_deserializeErrorNoSuchGeoLocation(response, errorBody) 4142 4143 default: 4144 genericError := &smithy.GenericAPIError{ 4145 Code: errorCode, 4146 Message: errorMessage, 4147 } 4148 return genericError 4149 4150 } 4151} 4152 4153func awsRestxml_deserializeOpDocumentGetGeoLocationOutput(v **GetGeoLocationOutput, decoder smithyxml.NodeDecoder) error { 4154 if v == nil { 4155 return fmt.Errorf("unexpected nil of type %T", v) 4156 } 4157 var sv *GetGeoLocationOutput 4158 if *v == nil { 4159 sv = &GetGeoLocationOutput{} 4160 } else { 4161 sv = *v 4162 } 4163 4164 for { 4165 t, done, err := decoder.Token() 4166 if err != nil { 4167 return err 4168 } 4169 if done { 4170 break 4171 } 4172 originalDecoder := decoder 4173 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4174 switch { 4175 case strings.EqualFold("GeoLocationDetails", t.Name.Local): 4176 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4177 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&sv.GeoLocationDetails, nodeDecoder); err != nil { 4178 return err 4179 } 4180 4181 default: 4182 // Do nothing and ignore the unexpected tag element 4183 err = decoder.Decoder.Skip() 4184 if err != nil { 4185 return err 4186 } 4187 4188 } 4189 decoder = originalDecoder 4190 } 4191 *v = sv 4192 return nil 4193} 4194 4195type awsRestxml_deserializeOpGetHealthCheck struct { 4196} 4197 4198func (*awsRestxml_deserializeOpGetHealthCheck) ID() string { 4199 return "OperationDeserializer" 4200} 4201 4202func (m *awsRestxml_deserializeOpGetHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4203 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4204) { 4205 out, metadata, err = next.HandleDeserialize(ctx, in) 4206 if err != nil { 4207 return out, metadata, err 4208 } 4209 4210 response, ok := out.RawResponse.(*smithyhttp.Response) 4211 if !ok { 4212 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4213 } 4214 4215 if response.StatusCode < 200 || response.StatusCode >= 300 { 4216 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheck(response, &metadata) 4217 } 4218 output := &GetHealthCheckOutput{} 4219 out.Result = output 4220 4221 var buff [1024]byte 4222 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4223 body := io.TeeReader(response.Body, ringBuffer) 4224 rootDecoder := xml.NewDecoder(body) 4225 t, err := smithyxml.FetchRootElement(rootDecoder) 4226 if err == io.EOF { 4227 return out, metadata, nil 4228 } 4229 if err != nil { 4230 var snapshot bytes.Buffer 4231 io.Copy(&snapshot, ringBuffer) 4232 return out, metadata, &smithy.DeserializationError{ 4233 Err: fmt.Errorf("failed to decode response body, %w", err), 4234 Snapshot: snapshot.Bytes(), 4235 } 4236 } 4237 4238 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4239 err = awsRestxml_deserializeOpDocumentGetHealthCheckOutput(&output, decoder) 4240 if err != nil { 4241 var snapshot bytes.Buffer 4242 io.Copy(&snapshot, ringBuffer) 4243 return out, metadata, &smithy.DeserializationError{ 4244 Err: fmt.Errorf("failed to decode response body, %w", err), 4245 Snapshot: snapshot.Bytes(), 4246 } 4247 } 4248 4249 return out, metadata, err 4250} 4251 4252func awsRestxml_deserializeOpErrorGetHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4253 var errorBuffer bytes.Buffer 4254 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4255 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4256 } 4257 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4258 4259 errorCode := "UnknownError" 4260 errorMessage := errorCode 4261 4262 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4263 if err != nil { 4264 return err 4265 } 4266 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4267 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4268 } 4269 if len(errorComponents.Code) != 0 { 4270 errorCode = errorComponents.Code 4271 } 4272 if len(errorComponents.Message) != 0 { 4273 errorMessage = errorComponents.Message 4274 } 4275 errorBody.Seek(0, io.SeekStart) 4276 switch { 4277 case strings.EqualFold("IncompatibleVersion", errorCode): 4278 return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody) 4279 4280 case strings.EqualFold("InvalidInput", errorCode): 4281 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4282 4283 case strings.EqualFold("NoSuchHealthCheck", errorCode): 4284 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 4285 4286 default: 4287 genericError := &smithy.GenericAPIError{ 4288 Code: errorCode, 4289 Message: errorMessage, 4290 } 4291 return genericError 4292 4293 } 4294} 4295 4296func awsRestxml_deserializeOpDocumentGetHealthCheckOutput(v **GetHealthCheckOutput, decoder smithyxml.NodeDecoder) error { 4297 if v == nil { 4298 return fmt.Errorf("unexpected nil of type %T", v) 4299 } 4300 var sv *GetHealthCheckOutput 4301 if *v == nil { 4302 sv = &GetHealthCheckOutput{} 4303 } else { 4304 sv = *v 4305 } 4306 4307 for { 4308 t, done, err := decoder.Token() 4309 if err != nil { 4310 return err 4311 } 4312 if done { 4313 break 4314 } 4315 originalDecoder := decoder 4316 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4317 switch { 4318 case strings.EqualFold("HealthCheck", t.Name.Local): 4319 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4320 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil { 4321 return err 4322 } 4323 4324 default: 4325 // Do nothing and ignore the unexpected tag element 4326 err = decoder.Decoder.Skip() 4327 if err != nil { 4328 return err 4329 } 4330 4331 } 4332 decoder = originalDecoder 4333 } 4334 *v = sv 4335 return nil 4336} 4337 4338type awsRestxml_deserializeOpGetHealthCheckCount struct { 4339} 4340 4341func (*awsRestxml_deserializeOpGetHealthCheckCount) ID() string { 4342 return "OperationDeserializer" 4343} 4344 4345func (m *awsRestxml_deserializeOpGetHealthCheckCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4346 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4347) { 4348 out, metadata, err = next.HandleDeserialize(ctx, in) 4349 if err != nil { 4350 return out, metadata, err 4351 } 4352 4353 response, ok := out.RawResponse.(*smithyhttp.Response) 4354 if !ok { 4355 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4356 } 4357 4358 if response.StatusCode < 200 || response.StatusCode >= 300 { 4359 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckCount(response, &metadata) 4360 } 4361 output := &GetHealthCheckCountOutput{} 4362 out.Result = output 4363 4364 var buff [1024]byte 4365 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4366 body := io.TeeReader(response.Body, ringBuffer) 4367 rootDecoder := xml.NewDecoder(body) 4368 t, err := smithyxml.FetchRootElement(rootDecoder) 4369 if err == io.EOF { 4370 return out, metadata, nil 4371 } 4372 if err != nil { 4373 var snapshot bytes.Buffer 4374 io.Copy(&snapshot, ringBuffer) 4375 return out, metadata, &smithy.DeserializationError{ 4376 Err: fmt.Errorf("failed to decode response body, %w", err), 4377 Snapshot: snapshot.Bytes(), 4378 } 4379 } 4380 4381 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4382 err = awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(&output, decoder) 4383 if err != nil { 4384 var snapshot bytes.Buffer 4385 io.Copy(&snapshot, ringBuffer) 4386 return out, metadata, &smithy.DeserializationError{ 4387 Err: fmt.Errorf("failed to decode response body, %w", err), 4388 Snapshot: snapshot.Bytes(), 4389 } 4390 } 4391 4392 return out, metadata, err 4393} 4394 4395func awsRestxml_deserializeOpErrorGetHealthCheckCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4396 var errorBuffer bytes.Buffer 4397 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4398 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4399 } 4400 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4401 4402 errorCode := "UnknownError" 4403 errorMessage := errorCode 4404 4405 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4406 if err != nil { 4407 return err 4408 } 4409 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4410 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4411 } 4412 if len(errorComponents.Code) != 0 { 4413 errorCode = errorComponents.Code 4414 } 4415 if len(errorComponents.Message) != 0 { 4416 errorMessage = errorComponents.Message 4417 } 4418 errorBody.Seek(0, io.SeekStart) 4419 switch { 4420 default: 4421 genericError := &smithy.GenericAPIError{ 4422 Code: errorCode, 4423 Message: errorMessage, 4424 } 4425 return genericError 4426 4427 } 4428} 4429 4430func awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(v **GetHealthCheckCountOutput, decoder smithyxml.NodeDecoder) error { 4431 if v == nil { 4432 return fmt.Errorf("unexpected nil of type %T", v) 4433 } 4434 var sv *GetHealthCheckCountOutput 4435 if *v == nil { 4436 sv = &GetHealthCheckCountOutput{} 4437 } else { 4438 sv = *v 4439 } 4440 4441 for { 4442 t, done, err := decoder.Token() 4443 if err != nil { 4444 return err 4445 } 4446 if done { 4447 break 4448 } 4449 originalDecoder := decoder 4450 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4451 switch { 4452 case strings.EqualFold("HealthCheckCount", t.Name.Local): 4453 val, err := decoder.Value() 4454 if err != nil { 4455 return err 4456 } 4457 if val == nil { 4458 break 4459 } 4460 { 4461 xtv := string(val) 4462 i64, err := strconv.ParseInt(xtv, 10, 64) 4463 if err != nil { 4464 return err 4465 } 4466 sv.HealthCheckCount = ptr.Int64(i64) 4467 } 4468 4469 default: 4470 // Do nothing and ignore the unexpected tag element 4471 err = decoder.Decoder.Skip() 4472 if err != nil { 4473 return err 4474 } 4475 4476 } 4477 decoder = originalDecoder 4478 } 4479 *v = sv 4480 return nil 4481} 4482 4483type awsRestxml_deserializeOpGetHealthCheckLastFailureReason struct { 4484} 4485 4486func (*awsRestxml_deserializeOpGetHealthCheckLastFailureReason) ID() string { 4487 return "OperationDeserializer" 4488} 4489 4490func (m *awsRestxml_deserializeOpGetHealthCheckLastFailureReason) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4491 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4492) { 4493 out, metadata, err = next.HandleDeserialize(ctx, in) 4494 if err != nil { 4495 return out, metadata, err 4496 } 4497 4498 response, ok := out.RawResponse.(*smithyhttp.Response) 4499 if !ok { 4500 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4501 } 4502 4503 if response.StatusCode < 200 || response.StatusCode >= 300 { 4504 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response, &metadata) 4505 } 4506 output := &GetHealthCheckLastFailureReasonOutput{} 4507 out.Result = output 4508 4509 var buff [1024]byte 4510 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4511 body := io.TeeReader(response.Body, ringBuffer) 4512 rootDecoder := xml.NewDecoder(body) 4513 t, err := smithyxml.FetchRootElement(rootDecoder) 4514 if err == io.EOF { 4515 return out, metadata, nil 4516 } 4517 if err != nil { 4518 var snapshot bytes.Buffer 4519 io.Copy(&snapshot, ringBuffer) 4520 return out, metadata, &smithy.DeserializationError{ 4521 Err: fmt.Errorf("failed to decode response body, %w", err), 4522 Snapshot: snapshot.Bytes(), 4523 } 4524 } 4525 4526 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4527 err = awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(&output, decoder) 4528 if err != nil { 4529 var snapshot bytes.Buffer 4530 io.Copy(&snapshot, ringBuffer) 4531 return out, metadata, &smithy.DeserializationError{ 4532 Err: fmt.Errorf("failed to decode response body, %w", err), 4533 Snapshot: snapshot.Bytes(), 4534 } 4535 } 4536 4537 return out, metadata, err 4538} 4539 4540func awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4541 var errorBuffer bytes.Buffer 4542 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4543 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4544 } 4545 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4546 4547 errorCode := "UnknownError" 4548 errorMessage := errorCode 4549 4550 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4551 if err != nil { 4552 return err 4553 } 4554 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4555 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4556 } 4557 if len(errorComponents.Code) != 0 { 4558 errorCode = errorComponents.Code 4559 } 4560 if len(errorComponents.Message) != 0 { 4561 errorMessage = errorComponents.Message 4562 } 4563 errorBody.Seek(0, io.SeekStart) 4564 switch { 4565 case strings.EqualFold("InvalidInput", errorCode): 4566 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4567 4568 case strings.EqualFold("NoSuchHealthCheck", errorCode): 4569 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 4570 4571 default: 4572 genericError := &smithy.GenericAPIError{ 4573 Code: errorCode, 4574 Message: errorMessage, 4575 } 4576 return genericError 4577 4578 } 4579} 4580 4581func awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(v **GetHealthCheckLastFailureReasonOutput, decoder smithyxml.NodeDecoder) error { 4582 if v == nil { 4583 return fmt.Errorf("unexpected nil of type %T", v) 4584 } 4585 var sv *GetHealthCheckLastFailureReasonOutput 4586 if *v == nil { 4587 sv = &GetHealthCheckLastFailureReasonOutput{} 4588 } else { 4589 sv = *v 4590 } 4591 4592 for { 4593 t, done, err := decoder.Token() 4594 if err != nil { 4595 return err 4596 } 4597 if done { 4598 break 4599 } 4600 originalDecoder := decoder 4601 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4602 switch { 4603 case strings.EqualFold("HealthCheckObservations", t.Name.Local): 4604 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4605 if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil { 4606 return err 4607 } 4608 4609 default: 4610 // Do nothing and ignore the unexpected tag element 4611 err = decoder.Decoder.Skip() 4612 if err != nil { 4613 return err 4614 } 4615 4616 } 4617 decoder = originalDecoder 4618 } 4619 *v = sv 4620 return nil 4621} 4622 4623type awsRestxml_deserializeOpGetHealthCheckStatus struct { 4624} 4625 4626func (*awsRestxml_deserializeOpGetHealthCheckStatus) ID() string { 4627 return "OperationDeserializer" 4628} 4629 4630func (m *awsRestxml_deserializeOpGetHealthCheckStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4631 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4632) { 4633 out, metadata, err = next.HandleDeserialize(ctx, in) 4634 if err != nil { 4635 return out, metadata, err 4636 } 4637 4638 response, ok := out.RawResponse.(*smithyhttp.Response) 4639 if !ok { 4640 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4641 } 4642 4643 if response.StatusCode < 200 || response.StatusCode >= 300 { 4644 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckStatus(response, &metadata) 4645 } 4646 output := &GetHealthCheckStatusOutput{} 4647 out.Result = output 4648 4649 var buff [1024]byte 4650 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4651 body := io.TeeReader(response.Body, ringBuffer) 4652 rootDecoder := xml.NewDecoder(body) 4653 t, err := smithyxml.FetchRootElement(rootDecoder) 4654 if err == io.EOF { 4655 return out, metadata, nil 4656 } 4657 if err != nil { 4658 var snapshot bytes.Buffer 4659 io.Copy(&snapshot, ringBuffer) 4660 return out, metadata, &smithy.DeserializationError{ 4661 Err: fmt.Errorf("failed to decode response body, %w", err), 4662 Snapshot: snapshot.Bytes(), 4663 } 4664 } 4665 4666 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4667 err = awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(&output, decoder) 4668 if err != nil { 4669 var snapshot bytes.Buffer 4670 io.Copy(&snapshot, ringBuffer) 4671 return out, metadata, &smithy.DeserializationError{ 4672 Err: fmt.Errorf("failed to decode response body, %w", err), 4673 Snapshot: snapshot.Bytes(), 4674 } 4675 } 4676 4677 return out, metadata, err 4678} 4679 4680func awsRestxml_deserializeOpErrorGetHealthCheckStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4681 var errorBuffer bytes.Buffer 4682 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4683 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4684 } 4685 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4686 4687 errorCode := "UnknownError" 4688 errorMessage := errorCode 4689 4690 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4691 if err != nil { 4692 return err 4693 } 4694 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4695 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4696 } 4697 if len(errorComponents.Code) != 0 { 4698 errorCode = errorComponents.Code 4699 } 4700 if len(errorComponents.Message) != 0 { 4701 errorMessage = errorComponents.Message 4702 } 4703 errorBody.Seek(0, io.SeekStart) 4704 switch { 4705 case strings.EqualFold("InvalidInput", errorCode): 4706 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4707 4708 case strings.EqualFold("NoSuchHealthCheck", errorCode): 4709 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 4710 4711 default: 4712 genericError := &smithy.GenericAPIError{ 4713 Code: errorCode, 4714 Message: errorMessage, 4715 } 4716 return genericError 4717 4718 } 4719} 4720 4721func awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(v **GetHealthCheckStatusOutput, decoder smithyxml.NodeDecoder) error { 4722 if v == nil { 4723 return fmt.Errorf("unexpected nil of type %T", v) 4724 } 4725 var sv *GetHealthCheckStatusOutput 4726 if *v == nil { 4727 sv = &GetHealthCheckStatusOutput{} 4728 } else { 4729 sv = *v 4730 } 4731 4732 for { 4733 t, done, err := decoder.Token() 4734 if err != nil { 4735 return err 4736 } 4737 if done { 4738 break 4739 } 4740 originalDecoder := decoder 4741 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4742 switch { 4743 case strings.EqualFold("HealthCheckObservations", t.Name.Local): 4744 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4745 if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil { 4746 return err 4747 } 4748 4749 default: 4750 // Do nothing and ignore the unexpected tag element 4751 err = decoder.Decoder.Skip() 4752 if err != nil { 4753 return err 4754 } 4755 4756 } 4757 decoder = originalDecoder 4758 } 4759 *v = sv 4760 return nil 4761} 4762 4763type awsRestxml_deserializeOpGetHostedZone struct { 4764} 4765 4766func (*awsRestxml_deserializeOpGetHostedZone) ID() string { 4767 return "OperationDeserializer" 4768} 4769 4770func (m *awsRestxml_deserializeOpGetHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4771 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4772) { 4773 out, metadata, err = next.HandleDeserialize(ctx, in) 4774 if err != nil { 4775 return out, metadata, err 4776 } 4777 4778 response, ok := out.RawResponse.(*smithyhttp.Response) 4779 if !ok { 4780 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4781 } 4782 4783 if response.StatusCode < 200 || response.StatusCode >= 300 { 4784 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZone(response, &metadata) 4785 } 4786 output := &GetHostedZoneOutput{} 4787 out.Result = output 4788 4789 var buff [1024]byte 4790 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4791 body := io.TeeReader(response.Body, ringBuffer) 4792 rootDecoder := xml.NewDecoder(body) 4793 t, err := smithyxml.FetchRootElement(rootDecoder) 4794 if err == io.EOF { 4795 return out, metadata, nil 4796 } 4797 if err != nil { 4798 var snapshot bytes.Buffer 4799 io.Copy(&snapshot, ringBuffer) 4800 return out, metadata, &smithy.DeserializationError{ 4801 Err: fmt.Errorf("failed to decode response body, %w", err), 4802 Snapshot: snapshot.Bytes(), 4803 } 4804 } 4805 4806 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4807 err = awsRestxml_deserializeOpDocumentGetHostedZoneOutput(&output, decoder) 4808 if err != nil { 4809 var snapshot bytes.Buffer 4810 io.Copy(&snapshot, ringBuffer) 4811 return out, metadata, &smithy.DeserializationError{ 4812 Err: fmt.Errorf("failed to decode response body, %w", err), 4813 Snapshot: snapshot.Bytes(), 4814 } 4815 } 4816 4817 return out, metadata, err 4818} 4819 4820func awsRestxml_deserializeOpErrorGetHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4821 var errorBuffer bytes.Buffer 4822 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4823 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4824 } 4825 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4826 4827 errorCode := "UnknownError" 4828 errorMessage := errorCode 4829 4830 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4831 if err != nil { 4832 return err 4833 } 4834 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4835 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4836 } 4837 if len(errorComponents.Code) != 0 { 4838 errorCode = errorComponents.Code 4839 } 4840 if len(errorComponents.Message) != 0 { 4841 errorMessage = errorComponents.Message 4842 } 4843 errorBody.Seek(0, io.SeekStart) 4844 switch { 4845 case strings.EqualFold("InvalidInput", errorCode): 4846 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4847 4848 case strings.EqualFold("NoSuchHostedZone", errorCode): 4849 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 4850 4851 default: 4852 genericError := &smithy.GenericAPIError{ 4853 Code: errorCode, 4854 Message: errorMessage, 4855 } 4856 return genericError 4857 4858 } 4859} 4860 4861func awsRestxml_deserializeOpDocumentGetHostedZoneOutput(v **GetHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 4862 if v == nil { 4863 return fmt.Errorf("unexpected nil of type %T", v) 4864 } 4865 var sv *GetHostedZoneOutput 4866 if *v == nil { 4867 sv = &GetHostedZoneOutput{} 4868 } else { 4869 sv = *v 4870 } 4871 4872 for { 4873 t, done, err := decoder.Token() 4874 if err != nil { 4875 return err 4876 } 4877 if done { 4878 break 4879 } 4880 originalDecoder := decoder 4881 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4882 switch { 4883 case strings.EqualFold("DelegationSet", t.Name.Local): 4884 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4885 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 4886 return err 4887 } 4888 4889 case strings.EqualFold("HostedZone", t.Name.Local): 4890 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4891 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil { 4892 return err 4893 } 4894 4895 case strings.EqualFold("VPCs", t.Name.Local): 4896 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4897 if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil { 4898 return err 4899 } 4900 4901 default: 4902 // Do nothing and ignore the unexpected tag element 4903 err = decoder.Decoder.Skip() 4904 if err != nil { 4905 return err 4906 } 4907 4908 } 4909 decoder = originalDecoder 4910 } 4911 *v = sv 4912 return nil 4913} 4914 4915type awsRestxml_deserializeOpGetHostedZoneCount struct { 4916} 4917 4918func (*awsRestxml_deserializeOpGetHostedZoneCount) ID() string { 4919 return "OperationDeserializer" 4920} 4921 4922func (m *awsRestxml_deserializeOpGetHostedZoneCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4923 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4924) { 4925 out, metadata, err = next.HandleDeserialize(ctx, in) 4926 if err != nil { 4927 return out, metadata, err 4928 } 4929 4930 response, ok := out.RawResponse.(*smithyhttp.Response) 4931 if !ok { 4932 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4933 } 4934 4935 if response.StatusCode < 200 || response.StatusCode >= 300 { 4936 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneCount(response, &metadata) 4937 } 4938 output := &GetHostedZoneCountOutput{} 4939 out.Result = output 4940 4941 var buff [1024]byte 4942 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4943 body := io.TeeReader(response.Body, ringBuffer) 4944 rootDecoder := xml.NewDecoder(body) 4945 t, err := smithyxml.FetchRootElement(rootDecoder) 4946 if err == io.EOF { 4947 return out, metadata, nil 4948 } 4949 if err != nil { 4950 var snapshot bytes.Buffer 4951 io.Copy(&snapshot, ringBuffer) 4952 return out, metadata, &smithy.DeserializationError{ 4953 Err: fmt.Errorf("failed to decode response body, %w", err), 4954 Snapshot: snapshot.Bytes(), 4955 } 4956 } 4957 4958 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4959 err = awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(&output, decoder) 4960 if err != nil { 4961 var snapshot bytes.Buffer 4962 io.Copy(&snapshot, ringBuffer) 4963 return out, metadata, &smithy.DeserializationError{ 4964 Err: fmt.Errorf("failed to decode response body, %w", err), 4965 Snapshot: snapshot.Bytes(), 4966 } 4967 } 4968 4969 return out, metadata, err 4970} 4971 4972func awsRestxml_deserializeOpErrorGetHostedZoneCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4973 var errorBuffer bytes.Buffer 4974 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4975 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4976 } 4977 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4978 4979 errorCode := "UnknownError" 4980 errorMessage := errorCode 4981 4982 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4983 if err != nil { 4984 return err 4985 } 4986 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4987 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4988 } 4989 if len(errorComponents.Code) != 0 { 4990 errorCode = errorComponents.Code 4991 } 4992 if len(errorComponents.Message) != 0 { 4993 errorMessage = errorComponents.Message 4994 } 4995 errorBody.Seek(0, io.SeekStart) 4996 switch { 4997 case strings.EqualFold("InvalidInput", errorCode): 4998 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 4999 5000 default: 5001 genericError := &smithy.GenericAPIError{ 5002 Code: errorCode, 5003 Message: errorMessage, 5004 } 5005 return genericError 5006 5007 } 5008} 5009 5010func awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(v **GetHostedZoneCountOutput, decoder smithyxml.NodeDecoder) error { 5011 if v == nil { 5012 return fmt.Errorf("unexpected nil of type %T", v) 5013 } 5014 var sv *GetHostedZoneCountOutput 5015 if *v == nil { 5016 sv = &GetHostedZoneCountOutput{} 5017 } else { 5018 sv = *v 5019 } 5020 5021 for { 5022 t, done, err := decoder.Token() 5023 if err != nil { 5024 return err 5025 } 5026 if done { 5027 break 5028 } 5029 originalDecoder := decoder 5030 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5031 switch { 5032 case strings.EqualFold("HostedZoneCount", t.Name.Local): 5033 val, err := decoder.Value() 5034 if err != nil { 5035 return err 5036 } 5037 if val == nil { 5038 break 5039 } 5040 { 5041 xtv := string(val) 5042 i64, err := strconv.ParseInt(xtv, 10, 64) 5043 if err != nil { 5044 return err 5045 } 5046 sv.HostedZoneCount = ptr.Int64(i64) 5047 } 5048 5049 default: 5050 // Do nothing and ignore the unexpected tag element 5051 err = decoder.Decoder.Skip() 5052 if err != nil { 5053 return err 5054 } 5055 5056 } 5057 decoder = originalDecoder 5058 } 5059 *v = sv 5060 return nil 5061} 5062 5063type awsRestxml_deserializeOpGetHostedZoneLimit struct { 5064} 5065 5066func (*awsRestxml_deserializeOpGetHostedZoneLimit) ID() string { 5067 return "OperationDeserializer" 5068} 5069 5070func (m *awsRestxml_deserializeOpGetHostedZoneLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5071 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5072) { 5073 out, metadata, err = next.HandleDeserialize(ctx, in) 5074 if err != nil { 5075 return out, metadata, err 5076 } 5077 5078 response, ok := out.RawResponse.(*smithyhttp.Response) 5079 if !ok { 5080 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5081 } 5082 5083 if response.StatusCode < 200 || response.StatusCode >= 300 { 5084 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneLimit(response, &metadata) 5085 } 5086 output := &GetHostedZoneLimitOutput{} 5087 out.Result = output 5088 5089 var buff [1024]byte 5090 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5091 body := io.TeeReader(response.Body, ringBuffer) 5092 rootDecoder := xml.NewDecoder(body) 5093 t, err := smithyxml.FetchRootElement(rootDecoder) 5094 if err == io.EOF { 5095 return out, metadata, nil 5096 } 5097 if err != nil { 5098 var snapshot bytes.Buffer 5099 io.Copy(&snapshot, ringBuffer) 5100 return out, metadata, &smithy.DeserializationError{ 5101 Err: fmt.Errorf("failed to decode response body, %w", err), 5102 Snapshot: snapshot.Bytes(), 5103 } 5104 } 5105 5106 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5107 err = awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(&output, decoder) 5108 if err != nil { 5109 var snapshot bytes.Buffer 5110 io.Copy(&snapshot, ringBuffer) 5111 return out, metadata, &smithy.DeserializationError{ 5112 Err: fmt.Errorf("failed to decode response body, %w", err), 5113 Snapshot: snapshot.Bytes(), 5114 } 5115 } 5116 5117 return out, metadata, err 5118} 5119 5120func awsRestxml_deserializeOpErrorGetHostedZoneLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5121 var errorBuffer bytes.Buffer 5122 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5123 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5124 } 5125 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5126 5127 errorCode := "UnknownError" 5128 errorMessage := errorCode 5129 5130 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5131 if err != nil { 5132 return err 5133 } 5134 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5135 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5136 } 5137 if len(errorComponents.Code) != 0 { 5138 errorCode = errorComponents.Code 5139 } 5140 if len(errorComponents.Message) != 0 { 5141 errorMessage = errorComponents.Message 5142 } 5143 errorBody.Seek(0, io.SeekStart) 5144 switch { 5145 case strings.EqualFold("HostedZoneNotPrivate", errorCode): 5146 return awsRestxml_deserializeErrorHostedZoneNotPrivate(response, errorBody) 5147 5148 case strings.EqualFold("InvalidInput", errorCode): 5149 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5150 5151 case strings.EqualFold("NoSuchHostedZone", errorCode): 5152 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 5153 5154 default: 5155 genericError := &smithy.GenericAPIError{ 5156 Code: errorCode, 5157 Message: errorMessage, 5158 } 5159 return genericError 5160 5161 } 5162} 5163 5164func awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(v **GetHostedZoneLimitOutput, decoder smithyxml.NodeDecoder) error { 5165 if v == nil { 5166 return fmt.Errorf("unexpected nil of type %T", v) 5167 } 5168 var sv *GetHostedZoneLimitOutput 5169 if *v == nil { 5170 sv = &GetHostedZoneLimitOutput{} 5171 } else { 5172 sv = *v 5173 } 5174 5175 for { 5176 t, done, err := decoder.Token() 5177 if err != nil { 5178 return err 5179 } 5180 if done { 5181 break 5182 } 5183 originalDecoder := decoder 5184 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5185 switch { 5186 case strings.EqualFold("Count", t.Name.Local): 5187 val, err := decoder.Value() 5188 if err != nil { 5189 return err 5190 } 5191 if val == nil { 5192 break 5193 } 5194 { 5195 xtv := string(val) 5196 i64, err := strconv.ParseInt(xtv, 10, 64) 5197 if err != nil { 5198 return err 5199 } 5200 sv.Count = i64 5201 } 5202 5203 case strings.EqualFold("Limit", t.Name.Local): 5204 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5205 if err := awsRestxml_deserializeDocumentHostedZoneLimit(&sv.Limit, nodeDecoder); err != nil { 5206 return err 5207 } 5208 5209 default: 5210 // Do nothing and ignore the unexpected tag element 5211 err = decoder.Decoder.Skip() 5212 if err != nil { 5213 return err 5214 } 5215 5216 } 5217 decoder = originalDecoder 5218 } 5219 *v = sv 5220 return nil 5221} 5222 5223type awsRestxml_deserializeOpGetQueryLoggingConfig struct { 5224} 5225 5226func (*awsRestxml_deserializeOpGetQueryLoggingConfig) ID() string { 5227 return "OperationDeserializer" 5228} 5229 5230func (m *awsRestxml_deserializeOpGetQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5231 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5232) { 5233 out, metadata, err = next.HandleDeserialize(ctx, in) 5234 if err != nil { 5235 return out, metadata, err 5236 } 5237 5238 response, ok := out.RawResponse.(*smithyhttp.Response) 5239 if !ok { 5240 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5241 } 5242 5243 if response.StatusCode < 200 || response.StatusCode >= 300 { 5244 return out, metadata, awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response, &metadata) 5245 } 5246 output := &GetQueryLoggingConfigOutput{} 5247 out.Result = output 5248 5249 var buff [1024]byte 5250 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5251 body := io.TeeReader(response.Body, ringBuffer) 5252 rootDecoder := xml.NewDecoder(body) 5253 t, err := smithyxml.FetchRootElement(rootDecoder) 5254 if err == io.EOF { 5255 return out, metadata, nil 5256 } 5257 if err != nil { 5258 var snapshot bytes.Buffer 5259 io.Copy(&snapshot, ringBuffer) 5260 return out, metadata, &smithy.DeserializationError{ 5261 Err: fmt.Errorf("failed to decode response body, %w", err), 5262 Snapshot: snapshot.Bytes(), 5263 } 5264 } 5265 5266 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5267 err = awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(&output, decoder) 5268 if err != nil { 5269 var snapshot bytes.Buffer 5270 io.Copy(&snapshot, ringBuffer) 5271 return out, metadata, &smithy.DeserializationError{ 5272 Err: fmt.Errorf("failed to decode response body, %w", err), 5273 Snapshot: snapshot.Bytes(), 5274 } 5275 } 5276 5277 return out, metadata, err 5278} 5279 5280func awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5281 var errorBuffer bytes.Buffer 5282 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5283 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5284 } 5285 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5286 5287 errorCode := "UnknownError" 5288 errorMessage := errorCode 5289 5290 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5291 if err != nil { 5292 return err 5293 } 5294 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5295 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5296 } 5297 if len(errorComponents.Code) != 0 { 5298 errorCode = errorComponents.Code 5299 } 5300 if len(errorComponents.Message) != 0 { 5301 errorMessage = errorComponents.Message 5302 } 5303 errorBody.Seek(0, io.SeekStart) 5304 switch { 5305 case strings.EqualFold("InvalidInput", errorCode): 5306 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5307 5308 case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode): 5309 return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody) 5310 5311 default: 5312 genericError := &smithy.GenericAPIError{ 5313 Code: errorCode, 5314 Message: errorMessage, 5315 } 5316 return genericError 5317 5318 } 5319} 5320 5321func awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(v **GetQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error { 5322 if v == nil { 5323 return fmt.Errorf("unexpected nil of type %T", v) 5324 } 5325 var sv *GetQueryLoggingConfigOutput 5326 if *v == nil { 5327 sv = &GetQueryLoggingConfigOutput{} 5328 } else { 5329 sv = *v 5330 } 5331 5332 for { 5333 t, done, err := decoder.Token() 5334 if err != nil { 5335 return err 5336 } 5337 if done { 5338 break 5339 } 5340 originalDecoder := decoder 5341 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5342 switch { 5343 case strings.EqualFold("QueryLoggingConfig", t.Name.Local): 5344 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5345 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil { 5346 return err 5347 } 5348 5349 default: 5350 // Do nothing and ignore the unexpected tag element 5351 err = decoder.Decoder.Skip() 5352 if err != nil { 5353 return err 5354 } 5355 5356 } 5357 decoder = originalDecoder 5358 } 5359 *v = sv 5360 return nil 5361} 5362 5363type awsRestxml_deserializeOpGetReusableDelegationSet struct { 5364} 5365 5366func (*awsRestxml_deserializeOpGetReusableDelegationSet) ID() string { 5367 return "OperationDeserializer" 5368} 5369 5370func (m *awsRestxml_deserializeOpGetReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5371 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5372) { 5373 out, metadata, err = next.HandleDeserialize(ctx, in) 5374 if err != nil { 5375 return out, metadata, err 5376 } 5377 5378 response, ok := out.RawResponse.(*smithyhttp.Response) 5379 if !ok { 5380 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5381 } 5382 5383 if response.StatusCode < 200 || response.StatusCode >= 300 { 5384 return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSet(response, &metadata) 5385 } 5386 output := &GetReusableDelegationSetOutput{} 5387 out.Result = output 5388 5389 var buff [1024]byte 5390 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5391 body := io.TeeReader(response.Body, ringBuffer) 5392 rootDecoder := xml.NewDecoder(body) 5393 t, err := smithyxml.FetchRootElement(rootDecoder) 5394 if err == io.EOF { 5395 return out, metadata, nil 5396 } 5397 if err != nil { 5398 var snapshot bytes.Buffer 5399 io.Copy(&snapshot, ringBuffer) 5400 return out, metadata, &smithy.DeserializationError{ 5401 Err: fmt.Errorf("failed to decode response body, %w", err), 5402 Snapshot: snapshot.Bytes(), 5403 } 5404 } 5405 5406 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5407 err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(&output, decoder) 5408 if err != nil { 5409 var snapshot bytes.Buffer 5410 io.Copy(&snapshot, ringBuffer) 5411 return out, metadata, &smithy.DeserializationError{ 5412 Err: fmt.Errorf("failed to decode response body, %w", err), 5413 Snapshot: snapshot.Bytes(), 5414 } 5415 } 5416 5417 return out, metadata, err 5418} 5419 5420func awsRestxml_deserializeOpErrorGetReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5421 var errorBuffer bytes.Buffer 5422 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5423 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5424 } 5425 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5426 5427 errorCode := "UnknownError" 5428 errorMessage := errorCode 5429 5430 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5431 if err != nil { 5432 return err 5433 } 5434 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5435 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5436 } 5437 if len(errorComponents.Code) != 0 { 5438 errorCode = errorComponents.Code 5439 } 5440 if len(errorComponents.Message) != 0 { 5441 errorMessage = errorComponents.Message 5442 } 5443 errorBody.Seek(0, io.SeekStart) 5444 switch { 5445 case strings.EqualFold("DelegationSetNotReusable", errorCode): 5446 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 5447 5448 case strings.EqualFold("InvalidInput", errorCode): 5449 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5450 5451 case strings.EqualFold("NoSuchDelegationSet", errorCode): 5452 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 5453 5454 default: 5455 genericError := &smithy.GenericAPIError{ 5456 Code: errorCode, 5457 Message: errorMessage, 5458 } 5459 return genericError 5460 5461 } 5462} 5463 5464func awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(v **GetReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error { 5465 if v == nil { 5466 return fmt.Errorf("unexpected nil of type %T", v) 5467 } 5468 var sv *GetReusableDelegationSetOutput 5469 if *v == nil { 5470 sv = &GetReusableDelegationSetOutput{} 5471 } else { 5472 sv = *v 5473 } 5474 5475 for { 5476 t, done, err := decoder.Token() 5477 if err != nil { 5478 return err 5479 } 5480 if done { 5481 break 5482 } 5483 originalDecoder := decoder 5484 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5485 switch { 5486 case strings.EqualFold("DelegationSet", t.Name.Local): 5487 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5488 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil { 5489 return err 5490 } 5491 5492 default: 5493 // Do nothing and ignore the unexpected tag element 5494 err = decoder.Decoder.Skip() 5495 if err != nil { 5496 return err 5497 } 5498 5499 } 5500 decoder = originalDecoder 5501 } 5502 *v = sv 5503 return nil 5504} 5505 5506type awsRestxml_deserializeOpGetReusableDelegationSetLimit struct { 5507} 5508 5509func (*awsRestxml_deserializeOpGetReusableDelegationSetLimit) ID() string { 5510 return "OperationDeserializer" 5511} 5512 5513func (m *awsRestxml_deserializeOpGetReusableDelegationSetLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5514 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5515) { 5516 out, metadata, err = next.HandleDeserialize(ctx, in) 5517 if err != nil { 5518 return out, metadata, err 5519 } 5520 5521 response, ok := out.RawResponse.(*smithyhttp.Response) 5522 if !ok { 5523 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5524 } 5525 5526 if response.StatusCode < 200 || response.StatusCode >= 300 { 5527 return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response, &metadata) 5528 } 5529 output := &GetReusableDelegationSetLimitOutput{} 5530 out.Result = output 5531 5532 var buff [1024]byte 5533 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5534 body := io.TeeReader(response.Body, ringBuffer) 5535 rootDecoder := xml.NewDecoder(body) 5536 t, err := smithyxml.FetchRootElement(rootDecoder) 5537 if err == io.EOF { 5538 return out, metadata, nil 5539 } 5540 if err != nil { 5541 var snapshot bytes.Buffer 5542 io.Copy(&snapshot, ringBuffer) 5543 return out, metadata, &smithy.DeserializationError{ 5544 Err: fmt.Errorf("failed to decode response body, %w", err), 5545 Snapshot: snapshot.Bytes(), 5546 } 5547 } 5548 5549 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5550 err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(&output, decoder) 5551 if err != nil { 5552 var snapshot bytes.Buffer 5553 io.Copy(&snapshot, ringBuffer) 5554 return out, metadata, &smithy.DeserializationError{ 5555 Err: fmt.Errorf("failed to decode response body, %w", err), 5556 Snapshot: snapshot.Bytes(), 5557 } 5558 } 5559 5560 return out, metadata, err 5561} 5562 5563func awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5564 var errorBuffer bytes.Buffer 5565 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5566 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5567 } 5568 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5569 5570 errorCode := "UnknownError" 5571 errorMessage := errorCode 5572 5573 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5574 if err != nil { 5575 return err 5576 } 5577 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5578 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5579 } 5580 if len(errorComponents.Code) != 0 { 5581 errorCode = errorComponents.Code 5582 } 5583 if len(errorComponents.Message) != 0 { 5584 errorMessage = errorComponents.Message 5585 } 5586 errorBody.Seek(0, io.SeekStart) 5587 switch { 5588 case strings.EqualFold("InvalidInput", errorCode): 5589 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5590 5591 case strings.EqualFold("NoSuchDelegationSet", errorCode): 5592 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 5593 5594 default: 5595 genericError := &smithy.GenericAPIError{ 5596 Code: errorCode, 5597 Message: errorMessage, 5598 } 5599 return genericError 5600 5601 } 5602} 5603 5604func awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(v **GetReusableDelegationSetLimitOutput, decoder smithyxml.NodeDecoder) error { 5605 if v == nil { 5606 return fmt.Errorf("unexpected nil of type %T", v) 5607 } 5608 var sv *GetReusableDelegationSetLimitOutput 5609 if *v == nil { 5610 sv = &GetReusableDelegationSetLimitOutput{} 5611 } else { 5612 sv = *v 5613 } 5614 5615 for { 5616 t, done, err := decoder.Token() 5617 if err != nil { 5618 return err 5619 } 5620 if done { 5621 break 5622 } 5623 originalDecoder := decoder 5624 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5625 switch { 5626 case strings.EqualFold("Count", t.Name.Local): 5627 val, err := decoder.Value() 5628 if err != nil { 5629 return err 5630 } 5631 if val == nil { 5632 break 5633 } 5634 { 5635 xtv := string(val) 5636 i64, err := strconv.ParseInt(xtv, 10, 64) 5637 if err != nil { 5638 return err 5639 } 5640 sv.Count = i64 5641 } 5642 5643 case strings.EqualFold("Limit", t.Name.Local): 5644 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5645 if err := awsRestxml_deserializeDocumentReusableDelegationSetLimit(&sv.Limit, nodeDecoder); err != nil { 5646 return err 5647 } 5648 5649 default: 5650 // Do nothing and ignore the unexpected tag element 5651 err = decoder.Decoder.Skip() 5652 if err != nil { 5653 return err 5654 } 5655 5656 } 5657 decoder = originalDecoder 5658 } 5659 *v = sv 5660 return nil 5661} 5662 5663type awsRestxml_deserializeOpGetTrafficPolicy struct { 5664} 5665 5666func (*awsRestxml_deserializeOpGetTrafficPolicy) ID() string { 5667 return "OperationDeserializer" 5668} 5669 5670func (m *awsRestxml_deserializeOpGetTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5671 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5672) { 5673 out, metadata, err = next.HandleDeserialize(ctx, in) 5674 if err != nil { 5675 return out, metadata, err 5676 } 5677 5678 response, ok := out.RawResponse.(*smithyhttp.Response) 5679 if !ok { 5680 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5681 } 5682 5683 if response.StatusCode < 200 || response.StatusCode >= 300 { 5684 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicy(response, &metadata) 5685 } 5686 output := &GetTrafficPolicyOutput{} 5687 out.Result = output 5688 5689 var buff [1024]byte 5690 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5691 body := io.TeeReader(response.Body, ringBuffer) 5692 rootDecoder := xml.NewDecoder(body) 5693 t, err := smithyxml.FetchRootElement(rootDecoder) 5694 if err == io.EOF { 5695 return out, metadata, nil 5696 } 5697 if err != nil { 5698 var snapshot bytes.Buffer 5699 io.Copy(&snapshot, ringBuffer) 5700 return out, metadata, &smithy.DeserializationError{ 5701 Err: fmt.Errorf("failed to decode response body, %w", err), 5702 Snapshot: snapshot.Bytes(), 5703 } 5704 } 5705 5706 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5707 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(&output, decoder) 5708 if err != nil { 5709 var snapshot bytes.Buffer 5710 io.Copy(&snapshot, ringBuffer) 5711 return out, metadata, &smithy.DeserializationError{ 5712 Err: fmt.Errorf("failed to decode response body, %w", err), 5713 Snapshot: snapshot.Bytes(), 5714 } 5715 } 5716 5717 return out, metadata, err 5718} 5719 5720func awsRestxml_deserializeOpErrorGetTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5721 var errorBuffer bytes.Buffer 5722 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5723 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5724 } 5725 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5726 5727 errorCode := "UnknownError" 5728 errorMessage := errorCode 5729 5730 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5731 if err != nil { 5732 return err 5733 } 5734 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5735 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5736 } 5737 if len(errorComponents.Code) != 0 { 5738 errorCode = errorComponents.Code 5739 } 5740 if len(errorComponents.Message) != 0 { 5741 errorMessage = errorComponents.Message 5742 } 5743 errorBody.Seek(0, io.SeekStart) 5744 switch { 5745 case strings.EqualFold("InvalidInput", errorCode): 5746 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5747 5748 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 5749 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 5750 5751 default: 5752 genericError := &smithy.GenericAPIError{ 5753 Code: errorCode, 5754 Message: errorMessage, 5755 } 5756 return genericError 5757 5758 } 5759} 5760 5761func awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(v **GetTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error { 5762 if v == nil { 5763 return fmt.Errorf("unexpected nil of type %T", v) 5764 } 5765 var sv *GetTrafficPolicyOutput 5766 if *v == nil { 5767 sv = &GetTrafficPolicyOutput{} 5768 } else { 5769 sv = *v 5770 } 5771 5772 for { 5773 t, done, err := decoder.Token() 5774 if err != nil { 5775 return err 5776 } 5777 if done { 5778 break 5779 } 5780 originalDecoder := decoder 5781 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5782 switch { 5783 case strings.EqualFold("TrafficPolicy", t.Name.Local): 5784 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5785 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 5786 return err 5787 } 5788 5789 default: 5790 // Do nothing and ignore the unexpected tag element 5791 err = decoder.Decoder.Skip() 5792 if err != nil { 5793 return err 5794 } 5795 5796 } 5797 decoder = originalDecoder 5798 } 5799 *v = sv 5800 return nil 5801} 5802 5803type awsRestxml_deserializeOpGetTrafficPolicyInstance struct { 5804} 5805 5806func (*awsRestxml_deserializeOpGetTrafficPolicyInstance) ID() string { 5807 return "OperationDeserializer" 5808} 5809 5810func (m *awsRestxml_deserializeOpGetTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5811 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5812) { 5813 out, metadata, err = next.HandleDeserialize(ctx, in) 5814 if err != nil { 5815 return out, metadata, err 5816 } 5817 5818 response, ok := out.RawResponse.(*smithyhttp.Response) 5819 if !ok { 5820 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5821 } 5822 5823 if response.StatusCode < 200 || response.StatusCode >= 300 { 5824 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response, &metadata) 5825 } 5826 output := &GetTrafficPolicyInstanceOutput{} 5827 out.Result = output 5828 5829 var buff [1024]byte 5830 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5831 body := io.TeeReader(response.Body, ringBuffer) 5832 rootDecoder := xml.NewDecoder(body) 5833 t, err := smithyxml.FetchRootElement(rootDecoder) 5834 if err == io.EOF { 5835 return out, metadata, nil 5836 } 5837 if err != nil { 5838 var snapshot bytes.Buffer 5839 io.Copy(&snapshot, ringBuffer) 5840 return out, metadata, &smithy.DeserializationError{ 5841 Err: fmt.Errorf("failed to decode response body, %w", err), 5842 Snapshot: snapshot.Bytes(), 5843 } 5844 } 5845 5846 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5847 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(&output, decoder) 5848 if err != nil { 5849 var snapshot bytes.Buffer 5850 io.Copy(&snapshot, ringBuffer) 5851 return out, metadata, &smithy.DeserializationError{ 5852 Err: fmt.Errorf("failed to decode response body, %w", err), 5853 Snapshot: snapshot.Bytes(), 5854 } 5855 } 5856 5857 return out, metadata, err 5858} 5859 5860func awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5861 var errorBuffer bytes.Buffer 5862 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5863 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5864 } 5865 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5866 5867 errorCode := "UnknownError" 5868 errorMessage := errorCode 5869 5870 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5871 if err != nil { 5872 return err 5873 } 5874 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5875 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5876 } 5877 if len(errorComponents.Code) != 0 { 5878 errorCode = errorComponents.Code 5879 } 5880 if len(errorComponents.Message) != 0 { 5881 errorMessage = errorComponents.Message 5882 } 5883 errorBody.Seek(0, io.SeekStart) 5884 switch { 5885 case strings.EqualFold("InvalidInput", errorCode): 5886 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 5887 5888 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 5889 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 5890 5891 default: 5892 genericError := &smithy.GenericAPIError{ 5893 Code: errorCode, 5894 Message: errorMessage, 5895 } 5896 return genericError 5897 5898 } 5899} 5900 5901func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(v **GetTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error { 5902 if v == nil { 5903 return fmt.Errorf("unexpected nil of type %T", v) 5904 } 5905 var sv *GetTrafficPolicyInstanceOutput 5906 if *v == nil { 5907 sv = &GetTrafficPolicyInstanceOutput{} 5908 } else { 5909 sv = *v 5910 } 5911 5912 for { 5913 t, done, err := decoder.Token() 5914 if err != nil { 5915 return err 5916 } 5917 if done { 5918 break 5919 } 5920 originalDecoder := decoder 5921 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5922 switch { 5923 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 5924 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5925 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil { 5926 return err 5927 } 5928 5929 default: 5930 // Do nothing and ignore the unexpected tag element 5931 err = decoder.Decoder.Skip() 5932 if err != nil { 5933 return err 5934 } 5935 5936 } 5937 decoder = originalDecoder 5938 } 5939 *v = sv 5940 return nil 5941} 5942 5943type awsRestxml_deserializeOpGetTrafficPolicyInstanceCount struct { 5944} 5945 5946func (*awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) ID() string { 5947 return "OperationDeserializer" 5948} 5949 5950func (m *awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5951 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5952) { 5953 out, metadata, err = next.HandleDeserialize(ctx, in) 5954 if err != nil { 5955 return out, metadata, err 5956 } 5957 5958 response, ok := out.RawResponse.(*smithyhttp.Response) 5959 if !ok { 5960 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5961 } 5962 5963 if response.StatusCode < 200 || response.StatusCode >= 300 { 5964 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response, &metadata) 5965 } 5966 output := &GetTrafficPolicyInstanceCountOutput{} 5967 out.Result = output 5968 5969 var buff [1024]byte 5970 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5971 body := io.TeeReader(response.Body, ringBuffer) 5972 rootDecoder := xml.NewDecoder(body) 5973 t, err := smithyxml.FetchRootElement(rootDecoder) 5974 if err == io.EOF { 5975 return out, metadata, nil 5976 } 5977 if err != nil { 5978 var snapshot bytes.Buffer 5979 io.Copy(&snapshot, ringBuffer) 5980 return out, metadata, &smithy.DeserializationError{ 5981 Err: fmt.Errorf("failed to decode response body, %w", err), 5982 Snapshot: snapshot.Bytes(), 5983 } 5984 } 5985 5986 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5987 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(&output, decoder) 5988 if err != nil { 5989 var snapshot bytes.Buffer 5990 io.Copy(&snapshot, ringBuffer) 5991 return out, metadata, &smithy.DeserializationError{ 5992 Err: fmt.Errorf("failed to decode response body, %w", err), 5993 Snapshot: snapshot.Bytes(), 5994 } 5995 } 5996 5997 return out, metadata, err 5998} 5999 6000func awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6001 var errorBuffer bytes.Buffer 6002 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6003 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6004 } 6005 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6006 6007 errorCode := "UnknownError" 6008 errorMessage := errorCode 6009 6010 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6011 if err != nil { 6012 return err 6013 } 6014 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6015 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6016 } 6017 if len(errorComponents.Code) != 0 { 6018 errorCode = errorComponents.Code 6019 } 6020 if len(errorComponents.Message) != 0 { 6021 errorMessage = errorComponents.Message 6022 } 6023 errorBody.Seek(0, io.SeekStart) 6024 switch { 6025 default: 6026 genericError := &smithy.GenericAPIError{ 6027 Code: errorCode, 6028 Message: errorMessage, 6029 } 6030 return genericError 6031 6032 } 6033} 6034 6035func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(v **GetTrafficPolicyInstanceCountOutput, decoder smithyxml.NodeDecoder) error { 6036 if v == nil { 6037 return fmt.Errorf("unexpected nil of type %T", v) 6038 } 6039 var sv *GetTrafficPolicyInstanceCountOutput 6040 if *v == nil { 6041 sv = &GetTrafficPolicyInstanceCountOutput{} 6042 } else { 6043 sv = *v 6044 } 6045 6046 for { 6047 t, done, err := decoder.Token() 6048 if err != nil { 6049 return err 6050 } 6051 if done { 6052 break 6053 } 6054 originalDecoder := decoder 6055 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6056 switch { 6057 case strings.EqualFold("TrafficPolicyInstanceCount", t.Name.Local): 6058 val, err := decoder.Value() 6059 if err != nil { 6060 return err 6061 } 6062 if val == nil { 6063 break 6064 } 6065 { 6066 xtv := string(val) 6067 i64, err := strconv.ParseInt(xtv, 10, 64) 6068 if err != nil { 6069 return err 6070 } 6071 sv.TrafficPolicyInstanceCount = ptr.Int32(int32(i64)) 6072 } 6073 6074 default: 6075 // Do nothing and ignore the unexpected tag element 6076 err = decoder.Decoder.Skip() 6077 if err != nil { 6078 return err 6079 } 6080 6081 } 6082 decoder = originalDecoder 6083 } 6084 *v = sv 6085 return nil 6086} 6087 6088type awsRestxml_deserializeOpListGeoLocations struct { 6089} 6090 6091func (*awsRestxml_deserializeOpListGeoLocations) ID() string { 6092 return "OperationDeserializer" 6093} 6094 6095func (m *awsRestxml_deserializeOpListGeoLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6096 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6097) { 6098 out, metadata, err = next.HandleDeserialize(ctx, in) 6099 if err != nil { 6100 return out, metadata, err 6101 } 6102 6103 response, ok := out.RawResponse.(*smithyhttp.Response) 6104 if !ok { 6105 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6106 } 6107 6108 if response.StatusCode < 200 || response.StatusCode >= 300 { 6109 return out, metadata, awsRestxml_deserializeOpErrorListGeoLocations(response, &metadata) 6110 } 6111 output := &ListGeoLocationsOutput{} 6112 out.Result = output 6113 6114 var buff [1024]byte 6115 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6116 body := io.TeeReader(response.Body, ringBuffer) 6117 rootDecoder := xml.NewDecoder(body) 6118 t, err := smithyxml.FetchRootElement(rootDecoder) 6119 if err == io.EOF { 6120 return out, metadata, nil 6121 } 6122 if err != nil { 6123 var snapshot bytes.Buffer 6124 io.Copy(&snapshot, ringBuffer) 6125 return out, metadata, &smithy.DeserializationError{ 6126 Err: fmt.Errorf("failed to decode response body, %w", err), 6127 Snapshot: snapshot.Bytes(), 6128 } 6129 } 6130 6131 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6132 err = awsRestxml_deserializeOpDocumentListGeoLocationsOutput(&output, decoder) 6133 if err != nil { 6134 var snapshot bytes.Buffer 6135 io.Copy(&snapshot, ringBuffer) 6136 return out, metadata, &smithy.DeserializationError{ 6137 Err: fmt.Errorf("failed to decode response body, %w", err), 6138 Snapshot: snapshot.Bytes(), 6139 } 6140 } 6141 6142 return out, metadata, err 6143} 6144 6145func awsRestxml_deserializeOpErrorListGeoLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6146 var errorBuffer bytes.Buffer 6147 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6148 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6149 } 6150 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6151 6152 errorCode := "UnknownError" 6153 errorMessage := errorCode 6154 6155 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6156 if err != nil { 6157 return err 6158 } 6159 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6160 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6161 } 6162 if len(errorComponents.Code) != 0 { 6163 errorCode = errorComponents.Code 6164 } 6165 if len(errorComponents.Message) != 0 { 6166 errorMessage = errorComponents.Message 6167 } 6168 errorBody.Seek(0, io.SeekStart) 6169 switch { 6170 case strings.EqualFold("InvalidInput", errorCode): 6171 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6172 6173 default: 6174 genericError := &smithy.GenericAPIError{ 6175 Code: errorCode, 6176 Message: errorMessage, 6177 } 6178 return genericError 6179 6180 } 6181} 6182 6183func awsRestxml_deserializeOpDocumentListGeoLocationsOutput(v **ListGeoLocationsOutput, decoder smithyxml.NodeDecoder) error { 6184 if v == nil { 6185 return fmt.Errorf("unexpected nil of type %T", v) 6186 } 6187 var sv *ListGeoLocationsOutput 6188 if *v == nil { 6189 sv = &ListGeoLocationsOutput{} 6190 } else { 6191 sv = *v 6192 } 6193 6194 for { 6195 t, done, err := decoder.Token() 6196 if err != nil { 6197 return err 6198 } 6199 if done { 6200 break 6201 } 6202 originalDecoder := decoder 6203 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6204 switch { 6205 case strings.EqualFold("GeoLocationDetailsList", t.Name.Local): 6206 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6207 if err := awsRestxml_deserializeDocumentGeoLocationDetailsList(&sv.GeoLocationDetailsList, nodeDecoder); err != nil { 6208 return err 6209 } 6210 6211 case strings.EqualFold("IsTruncated", t.Name.Local): 6212 val, err := decoder.Value() 6213 if err != nil { 6214 return err 6215 } 6216 if val == nil { 6217 break 6218 } 6219 { 6220 xtv, err := strconv.ParseBool(string(val)) 6221 if err != nil { 6222 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6223 } 6224 sv.IsTruncated = xtv 6225 } 6226 6227 case strings.EqualFold("MaxItems", t.Name.Local): 6228 val, err := decoder.Value() 6229 if err != nil { 6230 return err 6231 } 6232 if val == nil { 6233 break 6234 } 6235 { 6236 xtv := string(val) 6237 i64, err := strconv.ParseInt(xtv, 10, 64) 6238 if err != nil { 6239 return err 6240 } 6241 sv.MaxItems = ptr.Int32(int32(i64)) 6242 } 6243 6244 case strings.EqualFold("NextContinentCode", t.Name.Local): 6245 val, err := decoder.Value() 6246 if err != nil { 6247 return err 6248 } 6249 if val == nil { 6250 break 6251 } 6252 { 6253 xtv := string(val) 6254 sv.NextContinentCode = ptr.String(xtv) 6255 } 6256 6257 case strings.EqualFold("NextCountryCode", t.Name.Local): 6258 val, err := decoder.Value() 6259 if err != nil { 6260 return err 6261 } 6262 if val == nil { 6263 break 6264 } 6265 { 6266 xtv := string(val) 6267 sv.NextCountryCode = ptr.String(xtv) 6268 } 6269 6270 case strings.EqualFold("NextSubdivisionCode", t.Name.Local): 6271 val, err := decoder.Value() 6272 if err != nil { 6273 return err 6274 } 6275 if val == nil { 6276 break 6277 } 6278 { 6279 xtv := string(val) 6280 sv.NextSubdivisionCode = ptr.String(xtv) 6281 } 6282 6283 default: 6284 // Do nothing and ignore the unexpected tag element 6285 err = decoder.Decoder.Skip() 6286 if err != nil { 6287 return err 6288 } 6289 6290 } 6291 decoder = originalDecoder 6292 } 6293 *v = sv 6294 return nil 6295} 6296 6297type awsRestxml_deserializeOpListHealthChecks struct { 6298} 6299 6300func (*awsRestxml_deserializeOpListHealthChecks) ID() string { 6301 return "OperationDeserializer" 6302} 6303 6304func (m *awsRestxml_deserializeOpListHealthChecks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6305 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6306) { 6307 out, metadata, err = next.HandleDeserialize(ctx, in) 6308 if err != nil { 6309 return out, metadata, err 6310 } 6311 6312 response, ok := out.RawResponse.(*smithyhttp.Response) 6313 if !ok { 6314 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6315 } 6316 6317 if response.StatusCode < 200 || response.StatusCode >= 300 { 6318 return out, metadata, awsRestxml_deserializeOpErrorListHealthChecks(response, &metadata) 6319 } 6320 output := &ListHealthChecksOutput{} 6321 out.Result = output 6322 6323 var buff [1024]byte 6324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6325 body := io.TeeReader(response.Body, ringBuffer) 6326 rootDecoder := xml.NewDecoder(body) 6327 t, err := smithyxml.FetchRootElement(rootDecoder) 6328 if err == io.EOF { 6329 return out, metadata, nil 6330 } 6331 if err != nil { 6332 var snapshot bytes.Buffer 6333 io.Copy(&snapshot, ringBuffer) 6334 return out, metadata, &smithy.DeserializationError{ 6335 Err: fmt.Errorf("failed to decode response body, %w", err), 6336 Snapshot: snapshot.Bytes(), 6337 } 6338 } 6339 6340 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6341 err = awsRestxml_deserializeOpDocumentListHealthChecksOutput(&output, decoder) 6342 if err != nil { 6343 var snapshot bytes.Buffer 6344 io.Copy(&snapshot, ringBuffer) 6345 return out, metadata, &smithy.DeserializationError{ 6346 Err: fmt.Errorf("failed to decode response body, %w", err), 6347 Snapshot: snapshot.Bytes(), 6348 } 6349 } 6350 6351 return out, metadata, err 6352} 6353 6354func awsRestxml_deserializeOpErrorListHealthChecks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6355 var errorBuffer bytes.Buffer 6356 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6357 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6358 } 6359 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6360 6361 errorCode := "UnknownError" 6362 errorMessage := errorCode 6363 6364 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6365 if err != nil { 6366 return err 6367 } 6368 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6369 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6370 } 6371 if len(errorComponents.Code) != 0 { 6372 errorCode = errorComponents.Code 6373 } 6374 if len(errorComponents.Message) != 0 { 6375 errorMessage = errorComponents.Message 6376 } 6377 errorBody.Seek(0, io.SeekStart) 6378 switch { 6379 case strings.EqualFold("IncompatibleVersion", errorCode): 6380 return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody) 6381 6382 case strings.EqualFold("InvalidInput", errorCode): 6383 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6384 6385 default: 6386 genericError := &smithy.GenericAPIError{ 6387 Code: errorCode, 6388 Message: errorMessage, 6389 } 6390 return genericError 6391 6392 } 6393} 6394 6395func awsRestxml_deserializeOpDocumentListHealthChecksOutput(v **ListHealthChecksOutput, decoder smithyxml.NodeDecoder) error { 6396 if v == nil { 6397 return fmt.Errorf("unexpected nil of type %T", v) 6398 } 6399 var sv *ListHealthChecksOutput 6400 if *v == nil { 6401 sv = &ListHealthChecksOutput{} 6402 } else { 6403 sv = *v 6404 } 6405 6406 for { 6407 t, done, err := decoder.Token() 6408 if err != nil { 6409 return err 6410 } 6411 if done { 6412 break 6413 } 6414 originalDecoder := decoder 6415 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6416 switch { 6417 case strings.EqualFold("HealthChecks", t.Name.Local): 6418 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6419 if err := awsRestxml_deserializeDocumentHealthChecks(&sv.HealthChecks, nodeDecoder); err != nil { 6420 return err 6421 } 6422 6423 case strings.EqualFold("IsTruncated", t.Name.Local): 6424 val, err := decoder.Value() 6425 if err != nil { 6426 return err 6427 } 6428 if val == nil { 6429 break 6430 } 6431 { 6432 xtv, err := strconv.ParseBool(string(val)) 6433 if err != nil { 6434 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6435 } 6436 sv.IsTruncated = xtv 6437 } 6438 6439 case strings.EqualFold("Marker", t.Name.Local): 6440 val, err := decoder.Value() 6441 if err != nil { 6442 return err 6443 } 6444 if val == nil { 6445 break 6446 } 6447 { 6448 xtv := string(val) 6449 sv.Marker = ptr.String(xtv) 6450 } 6451 6452 case strings.EqualFold("MaxItems", t.Name.Local): 6453 val, err := decoder.Value() 6454 if err != nil { 6455 return err 6456 } 6457 if val == nil { 6458 break 6459 } 6460 { 6461 xtv := string(val) 6462 i64, err := strconv.ParseInt(xtv, 10, 64) 6463 if err != nil { 6464 return err 6465 } 6466 sv.MaxItems = ptr.Int32(int32(i64)) 6467 } 6468 6469 case strings.EqualFold("NextMarker", t.Name.Local): 6470 val, err := decoder.Value() 6471 if err != nil { 6472 return err 6473 } 6474 if val == nil { 6475 break 6476 } 6477 { 6478 xtv := string(val) 6479 sv.NextMarker = ptr.String(xtv) 6480 } 6481 6482 default: 6483 // Do nothing and ignore the unexpected tag element 6484 err = decoder.Decoder.Skip() 6485 if err != nil { 6486 return err 6487 } 6488 6489 } 6490 decoder = originalDecoder 6491 } 6492 *v = sv 6493 return nil 6494} 6495 6496type awsRestxml_deserializeOpListHostedZones struct { 6497} 6498 6499func (*awsRestxml_deserializeOpListHostedZones) ID() string { 6500 return "OperationDeserializer" 6501} 6502 6503func (m *awsRestxml_deserializeOpListHostedZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6504 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6505) { 6506 out, metadata, err = next.HandleDeserialize(ctx, in) 6507 if err != nil { 6508 return out, metadata, err 6509 } 6510 6511 response, ok := out.RawResponse.(*smithyhttp.Response) 6512 if !ok { 6513 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6514 } 6515 6516 if response.StatusCode < 200 || response.StatusCode >= 300 { 6517 return out, metadata, awsRestxml_deserializeOpErrorListHostedZones(response, &metadata) 6518 } 6519 output := &ListHostedZonesOutput{} 6520 out.Result = output 6521 6522 var buff [1024]byte 6523 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6524 body := io.TeeReader(response.Body, ringBuffer) 6525 rootDecoder := xml.NewDecoder(body) 6526 t, err := smithyxml.FetchRootElement(rootDecoder) 6527 if err == io.EOF { 6528 return out, metadata, nil 6529 } 6530 if err != nil { 6531 var snapshot bytes.Buffer 6532 io.Copy(&snapshot, ringBuffer) 6533 return out, metadata, &smithy.DeserializationError{ 6534 Err: fmt.Errorf("failed to decode response body, %w", err), 6535 Snapshot: snapshot.Bytes(), 6536 } 6537 } 6538 6539 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6540 err = awsRestxml_deserializeOpDocumentListHostedZonesOutput(&output, decoder) 6541 if err != nil { 6542 var snapshot bytes.Buffer 6543 io.Copy(&snapshot, ringBuffer) 6544 return out, metadata, &smithy.DeserializationError{ 6545 Err: fmt.Errorf("failed to decode response body, %w", err), 6546 Snapshot: snapshot.Bytes(), 6547 } 6548 } 6549 6550 return out, metadata, err 6551} 6552 6553func awsRestxml_deserializeOpErrorListHostedZones(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6554 var errorBuffer bytes.Buffer 6555 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6556 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6557 } 6558 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6559 6560 errorCode := "UnknownError" 6561 errorMessage := errorCode 6562 6563 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6564 if err != nil { 6565 return err 6566 } 6567 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6568 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6569 } 6570 if len(errorComponents.Code) != 0 { 6571 errorCode = errorComponents.Code 6572 } 6573 if len(errorComponents.Message) != 0 { 6574 errorMessage = errorComponents.Message 6575 } 6576 errorBody.Seek(0, io.SeekStart) 6577 switch { 6578 case strings.EqualFold("DelegationSetNotReusable", errorCode): 6579 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody) 6580 6581 case strings.EqualFold("InvalidInput", errorCode): 6582 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6583 6584 case strings.EqualFold("NoSuchDelegationSet", errorCode): 6585 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody) 6586 6587 default: 6588 genericError := &smithy.GenericAPIError{ 6589 Code: errorCode, 6590 Message: errorMessage, 6591 } 6592 return genericError 6593 6594 } 6595} 6596 6597func awsRestxml_deserializeOpDocumentListHostedZonesOutput(v **ListHostedZonesOutput, decoder smithyxml.NodeDecoder) error { 6598 if v == nil { 6599 return fmt.Errorf("unexpected nil of type %T", v) 6600 } 6601 var sv *ListHostedZonesOutput 6602 if *v == nil { 6603 sv = &ListHostedZonesOutput{} 6604 } else { 6605 sv = *v 6606 } 6607 6608 for { 6609 t, done, err := decoder.Token() 6610 if err != nil { 6611 return err 6612 } 6613 if done { 6614 break 6615 } 6616 originalDecoder := decoder 6617 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6618 switch { 6619 case strings.EqualFold("HostedZones", t.Name.Local): 6620 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6621 if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil { 6622 return err 6623 } 6624 6625 case strings.EqualFold("IsTruncated", t.Name.Local): 6626 val, err := decoder.Value() 6627 if err != nil { 6628 return err 6629 } 6630 if val == nil { 6631 break 6632 } 6633 { 6634 xtv, err := strconv.ParseBool(string(val)) 6635 if err != nil { 6636 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6637 } 6638 sv.IsTruncated = xtv 6639 } 6640 6641 case strings.EqualFold("Marker", t.Name.Local): 6642 val, err := decoder.Value() 6643 if err != nil { 6644 return err 6645 } 6646 if val == nil { 6647 break 6648 } 6649 { 6650 xtv := string(val) 6651 sv.Marker = ptr.String(xtv) 6652 } 6653 6654 case strings.EqualFold("MaxItems", t.Name.Local): 6655 val, err := decoder.Value() 6656 if err != nil { 6657 return err 6658 } 6659 if val == nil { 6660 break 6661 } 6662 { 6663 xtv := string(val) 6664 i64, err := strconv.ParseInt(xtv, 10, 64) 6665 if err != nil { 6666 return err 6667 } 6668 sv.MaxItems = ptr.Int32(int32(i64)) 6669 } 6670 6671 case strings.EqualFold("NextMarker", t.Name.Local): 6672 val, err := decoder.Value() 6673 if err != nil { 6674 return err 6675 } 6676 if val == nil { 6677 break 6678 } 6679 { 6680 xtv := string(val) 6681 sv.NextMarker = ptr.String(xtv) 6682 } 6683 6684 default: 6685 // Do nothing and ignore the unexpected tag element 6686 err = decoder.Decoder.Skip() 6687 if err != nil { 6688 return err 6689 } 6690 6691 } 6692 decoder = originalDecoder 6693 } 6694 *v = sv 6695 return nil 6696} 6697 6698type awsRestxml_deserializeOpListHostedZonesByName struct { 6699} 6700 6701func (*awsRestxml_deserializeOpListHostedZonesByName) ID() string { 6702 return "OperationDeserializer" 6703} 6704 6705func (m *awsRestxml_deserializeOpListHostedZonesByName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6706 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6707) { 6708 out, metadata, err = next.HandleDeserialize(ctx, in) 6709 if err != nil { 6710 return out, metadata, err 6711 } 6712 6713 response, ok := out.RawResponse.(*smithyhttp.Response) 6714 if !ok { 6715 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6716 } 6717 6718 if response.StatusCode < 200 || response.StatusCode >= 300 { 6719 return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByName(response, &metadata) 6720 } 6721 output := &ListHostedZonesByNameOutput{} 6722 out.Result = output 6723 6724 var buff [1024]byte 6725 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6726 body := io.TeeReader(response.Body, ringBuffer) 6727 rootDecoder := xml.NewDecoder(body) 6728 t, err := smithyxml.FetchRootElement(rootDecoder) 6729 if err == io.EOF { 6730 return out, metadata, nil 6731 } 6732 if err != nil { 6733 var snapshot bytes.Buffer 6734 io.Copy(&snapshot, ringBuffer) 6735 return out, metadata, &smithy.DeserializationError{ 6736 Err: fmt.Errorf("failed to decode response body, %w", err), 6737 Snapshot: snapshot.Bytes(), 6738 } 6739 } 6740 6741 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6742 err = awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(&output, decoder) 6743 if err != nil { 6744 var snapshot bytes.Buffer 6745 io.Copy(&snapshot, ringBuffer) 6746 return out, metadata, &smithy.DeserializationError{ 6747 Err: fmt.Errorf("failed to decode response body, %w", err), 6748 Snapshot: snapshot.Bytes(), 6749 } 6750 } 6751 6752 return out, metadata, err 6753} 6754 6755func awsRestxml_deserializeOpErrorListHostedZonesByName(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6756 var errorBuffer bytes.Buffer 6757 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6758 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6759 } 6760 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6761 6762 errorCode := "UnknownError" 6763 errorMessage := errorCode 6764 6765 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6766 if err != nil { 6767 return err 6768 } 6769 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6770 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6771 } 6772 if len(errorComponents.Code) != 0 { 6773 errorCode = errorComponents.Code 6774 } 6775 if len(errorComponents.Message) != 0 { 6776 errorMessage = errorComponents.Message 6777 } 6778 errorBody.Seek(0, io.SeekStart) 6779 switch { 6780 case strings.EqualFold("InvalidDomainName", errorCode): 6781 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody) 6782 6783 case strings.EqualFold("InvalidInput", errorCode): 6784 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 6785 6786 default: 6787 genericError := &smithy.GenericAPIError{ 6788 Code: errorCode, 6789 Message: errorMessage, 6790 } 6791 return genericError 6792 6793 } 6794} 6795 6796func awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(v **ListHostedZonesByNameOutput, decoder smithyxml.NodeDecoder) error { 6797 if v == nil { 6798 return fmt.Errorf("unexpected nil of type %T", v) 6799 } 6800 var sv *ListHostedZonesByNameOutput 6801 if *v == nil { 6802 sv = &ListHostedZonesByNameOutput{} 6803 } else { 6804 sv = *v 6805 } 6806 6807 for { 6808 t, done, err := decoder.Token() 6809 if err != nil { 6810 return err 6811 } 6812 if done { 6813 break 6814 } 6815 originalDecoder := decoder 6816 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6817 switch { 6818 case strings.EqualFold("DNSName", t.Name.Local): 6819 val, err := decoder.Value() 6820 if err != nil { 6821 return err 6822 } 6823 if val == nil { 6824 break 6825 } 6826 { 6827 xtv := string(val) 6828 sv.DNSName = ptr.String(xtv) 6829 } 6830 6831 case strings.EqualFold("HostedZoneId", t.Name.Local): 6832 val, err := decoder.Value() 6833 if err != nil { 6834 return err 6835 } 6836 if val == nil { 6837 break 6838 } 6839 { 6840 xtv := string(val) 6841 sv.HostedZoneId = ptr.String(xtv) 6842 } 6843 6844 case strings.EqualFold("HostedZones", t.Name.Local): 6845 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6846 if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil { 6847 return err 6848 } 6849 6850 case strings.EqualFold("IsTruncated", t.Name.Local): 6851 val, err := decoder.Value() 6852 if err != nil { 6853 return err 6854 } 6855 if val == nil { 6856 break 6857 } 6858 { 6859 xtv, err := strconv.ParseBool(string(val)) 6860 if err != nil { 6861 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 6862 } 6863 sv.IsTruncated = xtv 6864 } 6865 6866 case strings.EqualFold("MaxItems", t.Name.Local): 6867 val, err := decoder.Value() 6868 if err != nil { 6869 return err 6870 } 6871 if val == nil { 6872 break 6873 } 6874 { 6875 xtv := string(val) 6876 i64, err := strconv.ParseInt(xtv, 10, 64) 6877 if err != nil { 6878 return err 6879 } 6880 sv.MaxItems = ptr.Int32(int32(i64)) 6881 } 6882 6883 case strings.EqualFold("NextDNSName", t.Name.Local): 6884 val, err := decoder.Value() 6885 if err != nil { 6886 return err 6887 } 6888 if val == nil { 6889 break 6890 } 6891 { 6892 xtv := string(val) 6893 sv.NextDNSName = ptr.String(xtv) 6894 } 6895 6896 case strings.EqualFold("NextHostedZoneId", t.Name.Local): 6897 val, err := decoder.Value() 6898 if err != nil { 6899 return err 6900 } 6901 if val == nil { 6902 break 6903 } 6904 { 6905 xtv := string(val) 6906 sv.NextHostedZoneId = ptr.String(xtv) 6907 } 6908 6909 default: 6910 // Do nothing and ignore the unexpected tag element 6911 err = decoder.Decoder.Skip() 6912 if err != nil { 6913 return err 6914 } 6915 6916 } 6917 decoder = originalDecoder 6918 } 6919 *v = sv 6920 return nil 6921} 6922 6923type awsRestxml_deserializeOpListHostedZonesByVPC struct { 6924} 6925 6926func (*awsRestxml_deserializeOpListHostedZonesByVPC) ID() string { 6927 return "OperationDeserializer" 6928} 6929 6930func (m *awsRestxml_deserializeOpListHostedZonesByVPC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6931 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6932) { 6933 out, metadata, err = next.HandleDeserialize(ctx, in) 6934 if err != nil { 6935 return out, metadata, err 6936 } 6937 6938 response, ok := out.RawResponse.(*smithyhttp.Response) 6939 if !ok { 6940 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6941 } 6942 6943 if response.StatusCode < 200 || response.StatusCode >= 300 { 6944 return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByVPC(response, &metadata) 6945 } 6946 output := &ListHostedZonesByVPCOutput{} 6947 out.Result = output 6948 6949 var buff [1024]byte 6950 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6951 body := io.TeeReader(response.Body, ringBuffer) 6952 rootDecoder := xml.NewDecoder(body) 6953 t, err := smithyxml.FetchRootElement(rootDecoder) 6954 if err == io.EOF { 6955 return out, metadata, nil 6956 } 6957 if err != nil { 6958 var snapshot bytes.Buffer 6959 io.Copy(&snapshot, ringBuffer) 6960 return out, metadata, &smithy.DeserializationError{ 6961 Err: fmt.Errorf("failed to decode response body, %w", err), 6962 Snapshot: snapshot.Bytes(), 6963 } 6964 } 6965 6966 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6967 err = awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(&output, decoder) 6968 if err != nil { 6969 var snapshot bytes.Buffer 6970 io.Copy(&snapshot, ringBuffer) 6971 return out, metadata, &smithy.DeserializationError{ 6972 Err: fmt.Errorf("failed to decode response body, %w", err), 6973 Snapshot: snapshot.Bytes(), 6974 } 6975 } 6976 6977 return out, metadata, err 6978} 6979 6980func awsRestxml_deserializeOpErrorListHostedZonesByVPC(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6981 var errorBuffer bytes.Buffer 6982 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6983 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6984 } 6985 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6986 6987 errorCode := "UnknownError" 6988 errorMessage := errorCode 6989 6990 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6991 if err != nil { 6992 return err 6993 } 6994 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6995 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6996 } 6997 if len(errorComponents.Code) != 0 { 6998 errorCode = errorComponents.Code 6999 } 7000 if len(errorComponents.Message) != 0 { 7001 errorMessage = errorComponents.Message 7002 } 7003 errorBody.Seek(0, io.SeekStart) 7004 switch { 7005 case strings.EqualFold("InvalidInput", errorCode): 7006 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7007 7008 case strings.EqualFold("InvalidPaginationToken", errorCode): 7009 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody) 7010 7011 default: 7012 genericError := &smithy.GenericAPIError{ 7013 Code: errorCode, 7014 Message: errorMessage, 7015 } 7016 return genericError 7017 7018 } 7019} 7020 7021func awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(v **ListHostedZonesByVPCOutput, decoder smithyxml.NodeDecoder) error { 7022 if v == nil { 7023 return fmt.Errorf("unexpected nil of type %T", v) 7024 } 7025 var sv *ListHostedZonesByVPCOutput 7026 if *v == nil { 7027 sv = &ListHostedZonesByVPCOutput{} 7028 } else { 7029 sv = *v 7030 } 7031 7032 for { 7033 t, done, err := decoder.Token() 7034 if err != nil { 7035 return err 7036 } 7037 if done { 7038 break 7039 } 7040 originalDecoder := decoder 7041 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7042 switch { 7043 case strings.EqualFold("HostedZoneSummaries", t.Name.Local): 7044 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7045 if err := awsRestxml_deserializeDocumentHostedZoneSummaries(&sv.HostedZoneSummaries, nodeDecoder); err != nil { 7046 return err 7047 } 7048 7049 case strings.EqualFold("MaxItems", t.Name.Local): 7050 val, err := decoder.Value() 7051 if err != nil { 7052 return err 7053 } 7054 if val == nil { 7055 break 7056 } 7057 { 7058 xtv := string(val) 7059 i64, err := strconv.ParseInt(xtv, 10, 64) 7060 if err != nil { 7061 return err 7062 } 7063 sv.MaxItems = ptr.Int32(int32(i64)) 7064 } 7065 7066 case strings.EqualFold("NextToken", t.Name.Local): 7067 val, err := decoder.Value() 7068 if err != nil { 7069 return err 7070 } 7071 if val == nil { 7072 break 7073 } 7074 { 7075 xtv := string(val) 7076 sv.NextToken = ptr.String(xtv) 7077 } 7078 7079 default: 7080 // Do nothing and ignore the unexpected tag element 7081 err = decoder.Decoder.Skip() 7082 if err != nil { 7083 return err 7084 } 7085 7086 } 7087 decoder = originalDecoder 7088 } 7089 *v = sv 7090 return nil 7091} 7092 7093type awsRestxml_deserializeOpListQueryLoggingConfigs struct { 7094} 7095 7096func (*awsRestxml_deserializeOpListQueryLoggingConfigs) ID() string { 7097 return "OperationDeserializer" 7098} 7099 7100func (m *awsRestxml_deserializeOpListQueryLoggingConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7101 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7102) { 7103 out, metadata, err = next.HandleDeserialize(ctx, in) 7104 if err != nil { 7105 return out, metadata, err 7106 } 7107 7108 response, ok := out.RawResponse.(*smithyhttp.Response) 7109 if !ok { 7110 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7111 } 7112 7113 if response.StatusCode < 200 || response.StatusCode >= 300 { 7114 return out, metadata, awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response, &metadata) 7115 } 7116 output := &ListQueryLoggingConfigsOutput{} 7117 out.Result = output 7118 7119 var buff [1024]byte 7120 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7121 body := io.TeeReader(response.Body, ringBuffer) 7122 rootDecoder := xml.NewDecoder(body) 7123 t, err := smithyxml.FetchRootElement(rootDecoder) 7124 if err == io.EOF { 7125 return out, metadata, nil 7126 } 7127 if err != nil { 7128 var snapshot bytes.Buffer 7129 io.Copy(&snapshot, ringBuffer) 7130 return out, metadata, &smithy.DeserializationError{ 7131 Err: fmt.Errorf("failed to decode response body, %w", err), 7132 Snapshot: snapshot.Bytes(), 7133 } 7134 } 7135 7136 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7137 err = awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(&output, decoder) 7138 if err != nil { 7139 var snapshot bytes.Buffer 7140 io.Copy(&snapshot, ringBuffer) 7141 return out, metadata, &smithy.DeserializationError{ 7142 Err: fmt.Errorf("failed to decode response body, %w", err), 7143 Snapshot: snapshot.Bytes(), 7144 } 7145 } 7146 7147 return out, metadata, err 7148} 7149 7150func awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7151 var errorBuffer bytes.Buffer 7152 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7153 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7154 } 7155 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7156 7157 errorCode := "UnknownError" 7158 errorMessage := errorCode 7159 7160 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7161 if err != nil { 7162 return err 7163 } 7164 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7165 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7166 } 7167 if len(errorComponents.Code) != 0 { 7168 errorCode = errorComponents.Code 7169 } 7170 if len(errorComponents.Message) != 0 { 7171 errorMessage = errorComponents.Message 7172 } 7173 errorBody.Seek(0, io.SeekStart) 7174 switch { 7175 case strings.EqualFold("InvalidInput", errorCode): 7176 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7177 7178 case strings.EqualFold("InvalidPaginationToken", errorCode): 7179 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody) 7180 7181 case strings.EqualFold("NoSuchHostedZone", errorCode): 7182 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7183 7184 default: 7185 genericError := &smithy.GenericAPIError{ 7186 Code: errorCode, 7187 Message: errorMessage, 7188 } 7189 return genericError 7190 7191 } 7192} 7193 7194func awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(v **ListQueryLoggingConfigsOutput, decoder smithyxml.NodeDecoder) error { 7195 if v == nil { 7196 return fmt.Errorf("unexpected nil of type %T", v) 7197 } 7198 var sv *ListQueryLoggingConfigsOutput 7199 if *v == nil { 7200 sv = &ListQueryLoggingConfigsOutput{} 7201 } else { 7202 sv = *v 7203 } 7204 7205 for { 7206 t, done, err := decoder.Token() 7207 if err != nil { 7208 return err 7209 } 7210 if done { 7211 break 7212 } 7213 originalDecoder := decoder 7214 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7215 switch { 7216 case strings.EqualFold("NextToken", t.Name.Local): 7217 val, err := decoder.Value() 7218 if err != nil { 7219 return err 7220 } 7221 if val == nil { 7222 break 7223 } 7224 { 7225 xtv := string(val) 7226 sv.NextToken = ptr.String(xtv) 7227 } 7228 7229 case strings.EqualFold("QueryLoggingConfigs", t.Name.Local): 7230 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7231 if err := awsRestxml_deserializeDocumentQueryLoggingConfigs(&sv.QueryLoggingConfigs, nodeDecoder); err != nil { 7232 return err 7233 } 7234 7235 default: 7236 // Do nothing and ignore the unexpected tag element 7237 err = decoder.Decoder.Skip() 7238 if err != nil { 7239 return err 7240 } 7241 7242 } 7243 decoder = originalDecoder 7244 } 7245 *v = sv 7246 return nil 7247} 7248 7249type awsRestxml_deserializeOpListResourceRecordSets struct { 7250} 7251 7252func (*awsRestxml_deserializeOpListResourceRecordSets) ID() string { 7253 return "OperationDeserializer" 7254} 7255 7256func (m *awsRestxml_deserializeOpListResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7257 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7258) { 7259 out, metadata, err = next.HandleDeserialize(ctx, in) 7260 if err != nil { 7261 return out, metadata, err 7262 } 7263 7264 response, ok := out.RawResponse.(*smithyhttp.Response) 7265 if !ok { 7266 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7267 } 7268 7269 if response.StatusCode < 200 || response.StatusCode >= 300 { 7270 return out, metadata, awsRestxml_deserializeOpErrorListResourceRecordSets(response, &metadata) 7271 } 7272 output := &ListResourceRecordSetsOutput{} 7273 out.Result = output 7274 7275 var buff [1024]byte 7276 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7277 body := io.TeeReader(response.Body, ringBuffer) 7278 rootDecoder := xml.NewDecoder(body) 7279 t, err := smithyxml.FetchRootElement(rootDecoder) 7280 if err == io.EOF { 7281 return out, metadata, nil 7282 } 7283 if err != nil { 7284 var snapshot bytes.Buffer 7285 io.Copy(&snapshot, ringBuffer) 7286 return out, metadata, &smithy.DeserializationError{ 7287 Err: fmt.Errorf("failed to decode response body, %w", err), 7288 Snapshot: snapshot.Bytes(), 7289 } 7290 } 7291 7292 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7293 err = awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(&output, decoder) 7294 if err != nil { 7295 var snapshot bytes.Buffer 7296 io.Copy(&snapshot, ringBuffer) 7297 return out, metadata, &smithy.DeserializationError{ 7298 Err: fmt.Errorf("failed to decode response body, %w", err), 7299 Snapshot: snapshot.Bytes(), 7300 } 7301 } 7302 7303 return out, metadata, err 7304} 7305 7306func awsRestxml_deserializeOpErrorListResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7307 var errorBuffer bytes.Buffer 7308 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7309 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7310 } 7311 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7312 7313 errorCode := "UnknownError" 7314 errorMessage := errorCode 7315 7316 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7317 if err != nil { 7318 return err 7319 } 7320 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7321 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7322 } 7323 if len(errorComponents.Code) != 0 { 7324 errorCode = errorComponents.Code 7325 } 7326 if len(errorComponents.Message) != 0 { 7327 errorMessage = errorComponents.Message 7328 } 7329 errorBody.Seek(0, io.SeekStart) 7330 switch { 7331 case strings.EqualFold("InvalidInput", errorCode): 7332 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7333 7334 case strings.EqualFold("NoSuchHostedZone", errorCode): 7335 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7336 7337 default: 7338 genericError := &smithy.GenericAPIError{ 7339 Code: errorCode, 7340 Message: errorMessage, 7341 } 7342 return genericError 7343 7344 } 7345} 7346 7347func awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(v **ListResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error { 7348 if v == nil { 7349 return fmt.Errorf("unexpected nil of type %T", v) 7350 } 7351 var sv *ListResourceRecordSetsOutput 7352 if *v == nil { 7353 sv = &ListResourceRecordSetsOutput{} 7354 } else { 7355 sv = *v 7356 } 7357 7358 for { 7359 t, done, err := decoder.Token() 7360 if err != nil { 7361 return err 7362 } 7363 if done { 7364 break 7365 } 7366 originalDecoder := decoder 7367 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7368 switch { 7369 case strings.EqualFold("IsTruncated", t.Name.Local): 7370 val, err := decoder.Value() 7371 if err != nil { 7372 return err 7373 } 7374 if val == nil { 7375 break 7376 } 7377 { 7378 xtv, err := strconv.ParseBool(string(val)) 7379 if err != nil { 7380 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 7381 } 7382 sv.IsTruncated = xtv 7383 } 7384 7385 case strings.EqualFold("MaxItems", t.Name.Local): 7386 val, err := decoder.Value() 7387 if err != nil { 7388 return err 7389 } 7390 if val == nil { 7391 break 7392 } 7393 { 7394 xtv := string(val) 7395 i64, err := strconv.ParseInt(xtv, 10, 64) 7396 if err != nil { 7397 return err 7398 } 7399 sv.MaxItems = ptr.Int32(int32(i64)) 7400 } 7401 7402 case strings.EqualFold("NextRecordIdentifier", t.Name.Local): 7403 val, err := decoder.Value() 7404 if err != nil { 7405 return err 7406 } 7407 if val == nil { 7408 break 7409 } 7410 { 7411 xtv := string(val) 7412 sv.NextRecordIdentifier = ptr.String(xtv) 7413 } 7414 7415 case strings.EqualFold("NextRecordName", t.Name.Local): 7416 val, err := decoder.Value() 7417 if err != nil { 7418 return err 7419 } 7420 if val == nil { 7421 break 7422 } 7423 { 7424 xtv := string(val) 7425 sv.NextRecordName = ptr.String(xtv) 7426 } 7427 7428 case strings.EqualFold("NextRecordType", t.Name.Local): 7429 val, err := decoder.Value() 7430 if err != nil { 7431 return err 7432 } 7433 if val == nil { 7434 break 7435 } 7436 { 7437 xtv := string(val) 7438 sv.NextRecordType = types.RRType(xtv) 7439 } 7440 7441 case strings.EqualFold("ResourceRecordSets", t.Name.Local): 7442 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7443 if err := awsRestxml_deserializeDocumentResourceRecordSets(&sv.ResourceRecordSets, nodeDecoder); err != nil { 7444 return err 7445 } 7446 7447 default: 7448 // Do nothing and ignore the unexpected tag element 7449 err = decoder.Decoder.Skip() 7450 if err != nil { 7451 return err 7452 } 7453 7454 } 7455 decoder = originalDecoder 7456 } 7457 *v = sv 7458 return nil 7459} 7460 7461type awsRestxml_deserializeOpListReusableDelegationSets struct { 7462} 7463 7464func (*awsRestxml_deserializeOpListReusableDelegationSets) ID() string { 7465 return "OperationDeserializer" 7466} 7467 7468func (m *awsRestxml_deserializeOpListReusableDelegationSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7469 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7470) { 7471 out, metadata, err = next.HandleDeserialize(ctx, in) 7472 if err != nil { 7473 return out, metadata, err 7474 } 7475 7476 response, ok := out.RawResponse.(*smithyhttp.Response) 7477 if !ok { 7478 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7479 } 7480 7481 if response.StatusCode < 200 || response.StatusCode >= 300 { 7482 return out, metadata, awsRestxml_deserializeOpErrorListReusableDelegationSets(response, &metadata) 7483 } 7484 output := &ListReusableDelegationSetsOutput{} 7485 out.Result = output 7486 7487 var buff [1024]byte 7488 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7489 body := io.TeeReader(response.Body, ringBuffer) 7490 rootDecoder := xml.NewDecoder(body) 7491 t, err := smithyxml.FetchRootElement(rootDecoder) 7492 if err == io.EOF { 7493 return out, metadata, nil 7494 } 7495 if err != nil { 7496 var snapshot bytes.Buffer 7497 io.Copy(&snapshot, ringBuffer) 7498 return out, metadata, &smithy.DeserializationError{ 7499 Err: fmt.Errorf("failed to decode response body, %w", err), 7500 Snapshot: snapshot.Bytes(), 7501 } 7502 } 7503 7504 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7505 err = awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(&output, decoder) 7506 if err != nil { 7507 var snapshot bytes.Buffer 7508 io.Copy(&snapshot, ringBuffer) 7509 return out, metadata, &smithy.DeserializationError{ 7510 Err: fmt.Errorf("failed to decode response body, %w", err), 7511 Snapshot: snapshot.Bytes(), 7512 } 7513 } 7514 7515 return out, metadata, err 7516} 7517 7518func awsRestxml_deserializeOpErrorListReusableDelegationSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7519 var errorBuffer bytes.Buffer 7520 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7521 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7522 } 7523 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7524 7525 errorCode := "UnknownError" 7526 errorMessage := errorCode 7527 7528 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7529 if err != nil { 7530 return err 7531 } 7532 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7533 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7534 } 7535 if len(errorComponents.Code) != 0 { 7536 errorCode = errorComponents.Code 7537 } 7538 if len(errorComponents.Message) != 0 { 7539 errorMessage = errorComponents.Message 7540 } 7541 errorBody.Seek(0, io.SeekStart) 7542 switch { 7543 case strings.EqualFold("InvalidInput", errorCode): 7544 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7545 7546 default: 7547 genericError := &smithy.GenericAPIError{ 7548 Code: errorCode, 7549 Message: errorMessage, 7550 } 7551 return genericError 7552 7553 } 7554} 7555 7556func awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(v **ListReusableDelegationSetsOutput, decoder smithyxml.NodeDecoder) error { 7557 if v == nil { 7558 return fmt.Errorf("unexpected nil of type %T", v) 7559 } 7560 var sv *ListReusableDelegationSetsOutput 7561 if *v == nil { 7562 sv = &ListReusableDelegationSetsOutput{} 7563 } else { 7564 sv = *v 7565 } 7566 7567 for { 7568 t, done, err := decoder.Token() 7569 if err != nil { 7570 return err 7571 } 7572 if done { 7573 break 7574 } 7575 originalDecoder := decoder 7576 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7577 switch { 7578 case strings.EqualFold("DelegationSets", t.Name.Local): 7579 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7580 if err := awsRestxml_deserializeDocumentDelegationSets(&sv.DelegationSets, nodeDecoder); err != nil { 7581 return err 7582 } 7583 7584 case strings.EqualFold("IsTruncated", t.Name.Local): 7585 val, err := decoder.Value() 7586 if err != nil { 7587 return err 7588 } 7589 if val == nil { 7590 break 7591 } 7592 { 7593 xtv, err := strconv.ParseBool(string(val)) 7594 if err != nil { 7595 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 7596 } 7597 sv.IsTruncated = xtv 7598 } 7599 7600 case strings.EqualFold("Marker", t.Name.Local): 7601 val, err := decoder.Value() 7602 if err != nil { 7603 return err 7604 } 7605 if val == nil { 7606 break 7607 } 7608 { 7609 xtv := string(val) 7610 sv.Marker = ptr.String(xtv) 7611 } 7612 7613 case strings.EqualFold("MaxItems", t.Name.Local): 7614 val, err := decoder.Value() 7615 if err != nil { 7616 return err 7617 } 7618 if val == nil { 7619 break 7620 } 7621 { 7622 xtv := string(val) 7623 i64, err := strconv.ParseInt(xtv, 10, 64) 7624 if err != nil { 7625 return err 7626 } 7627 sv.MaxItems = ptr.Int32(int32(i64)) 7628 } 7629 7630 case strings.EqualFold("NextMarker", t.Name.Local): 7631 val, err := decoder.Value() 7632 if err != nil { 7633 return err 7634 } 7635 if val == nil { 7636 break 7637 } 7638 { 7639 xtv := string(val) 7640 sv.NextMarker = ptr.String(xtv) 7641 } 7642 7643 default: 7644 // Do nothing and ignore the unexpected tag element 7645 err = decoder.Decoder.Skip() 7646 if err != nil { 7647 return err 7648 } 7649 7650 } 7651 decoder = originalDecoder 7652 } 7653 *v = sv 7654 return nil 7655} 7656 7657type awsRestxml_deserializeOpListTagsForResource struct { 7658} 7659 7660func (*awsRestxml_deserializeOpListTagsForResource) ID() string { 7661 return "OperationDeserializer" 7662} 7663 7664func (m *awsRestxml_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7665 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7666) { 7667 out, metadata, err = next.HandleDeserialize(ctx, in) 7668 if err != nil { 7669 return out, metadata, err 7670 } 7671 7672 response, ok := out.RawResponse.(*smithyhttp.Response) 7673 if !ok { 7674 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7675 } 7676 7677 if response.StatusCode < 200 || response.StatusCode >= 300 { 7678 return out, metadata, awsRestxml_deserializeOpErrorListTagsForResource(response, &metadata) 7679 } 7680 output := &ListTagsForResourceOutput{} 7681 out.Result = output 7682 7683 var buff [1024]byte 7684 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7685 body := io.TeeReader(response.Body, ringBuffer) 7686 rootDecoder := xml.NewDecoder(body) 7687 t, err := smithyxml.FetchRootElement(rootDecoder) 7688 if err == io.EOF { 7689 return out, metadata, nil 7690 } 7691 if err != nil { 7692 var snapshot bytes.Buffer 7693 io.Copy(&snapshot, ringBuffer) 7694 return out, metadata, &smithy.DeserializationError{ 7695 Err: fmt.Errorf("failed to decode response body, %w", err), 7696 Snapshot: snapshot.Bytes(), 7697 } 7698 } 7699 7700 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7701 err = awsRestxml_deserializeOpDocumentListTagsForResourceOutput(&output, decoder) 7702 if err != nil { 7703 var snapshot bytes.Buffer 7704 io.Copy(&snapshot, ringBuffer) 7705 return out, metadata, &smithy.DeserializationError{ 7706 Err: fmt.Errorf("failed to decode response body, %w", err), 7707 Snapshot: snapshot.Bytes(), 7708 } 7709 } 7710 7711 return out, metadata, err 7712} 7713 7714func awsRestxml_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7715 var errorBuffer bytes.Buffer 7716 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7717 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7718 } 7719 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7720 7721 errorCode := "UnknownError" 7722 errorMessage := errorCode 7723 7724 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7725 if err != nil { 7726 return err 7727 } 7728 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7729 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7730 } 7731 if len(errorComponents.Code) != 0 { 7732 errorCode = errorComponents.Code 7733 } 7734 if len(errorComponents.Message) != 0 { 7735 errorMessage = errorComponents.Message 7736 } 7737 errorBody.Seek(0, io.SeekStart) 7738 switch { 7739 case strings.EqualFold("InvalidInput", errorCode): 7740 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7741 7742 case strings.EqualFold("NoSuchHealthCheck", errorCode): 7743 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 7744 7745 case strings.EqualFold("NoSuchHostedZone", errorCode): 7746 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7747 7748 case strings.EqualFold("PriorRequestNotComplete", errorCode): 7749 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 7750 7751 case strings.EqualFold("ThrottlingException", errorCode): 7752 return awsRestxml_deserializeErrorThrottlingException(response, errorBody) 7753 7754 default: 7755 genericError := &smithy.GenericAPIError{ 7756 Code: errorCode, 7757 Message: errorMessage, 7758 } 7759 return genericError 7760 7761 } 7762} 7763 7764func awsRestxml_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error { 7765 if v == nil { 7766 return fmt.Errorf("unexpected nil of type %T", v) 7767 } 7768 var sv *ListTagsForResourceOutput 7769 if *v == nil { 7770 sv = &ListTagsForResourceOutput{} 7771 } else { 7772 sv = *v 7773 } 7774 7775 for { 7776 t, done, err := decoder.Token() 7777 if err != nil { 7778 return err 7779 } 7780 if done { 7781 break 7782 } 7783 originalDecoder := decoder 7784 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7785 switch { 7786 case strings.EqualFold("ResourceTagSet", t.Name.Local): 7787 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7788 if err := awsRestxml_deserializeDocumentResourceTagSet(&sv.ResourceTagSet, nodeDecoder); err != nil { 7789 return err 7790 } 7791 7792 default: 7793 // Do nothing and ignore the unexpected tag element 7794 err = decoder.Decoder.Skip() 7795 if err != nil { 7796 return err 7797 } 7798 7799 } 7800 decoder = originalDecoder 7801 } 7802 *v = sv 7803 return nil 7804} 7805 7806type awsRestxml_deserializeOpListTagsForResources struct { 7807} 7808 7809func (*awsRestxml_deserializeOpListTagsForResources) ID() string { 7810 return "OperationDeserializer" 7811} 7812 7813func (m *awsRestxml_deserializeOpListTagsForResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7814 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7815) { 7816 out, metadata, err = next.HandleDeserialize(ctx, in) 7817 if err != nil { 7818 return out, metadata, err 7819 } 7820 7821 response, ok := out.RawResponse.(*smithyhttp.Response) 7822 if !ok { 7823 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7824 } 7825 7826 if response.StatusCode < 200 || response.StatusCode >= 300 { 7827 return out, metadata, awsRestxml_deserializeOpErrorListTagsForResources(response, &metadata) 7828 } 7829 output := &ListTagsForResourcesOutput{} 7830 out.Result = output 7831 7832 var buff [1024]byte 7833 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7834 body := io.TeeReader(response.Body, ringBuffer) 7835 rootDecoder := xml.NewDecoder(body) 7836 t, err := smithyxml.FetchRootElement(rootDecoder) 7837 if err == io.EOF { 7838 return out, metadata, nil 7839 } 7840 if err != nil { 7841 var snapshot bytes.Buffer 7842 io.Copy(&snapshot, ringBuffer) 7843 return out, metadata, &smithy.DeserializationError{ 7844 Err: fmt.Errorf("failed to decode response body, %w", err), 7845 Snapshot: snapshot.Bytes(), 7846 } 7847 } 7848 7849 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7850 err = awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(&output, decoder) 7851 if err != nil { 7852 var snapshot bytes.Buffer 7853 io.Copy(&snapshot, ringBuffer) 7854 return out, metadata, &smithy.DeserializationError{ 7855 Err: fmt.Errorf("failed to decode response body, %w", err), 7856 Snapshot: snapshot.Bytes(), 7857 } 7858 } 7859 7860 return out, metadata, err 7861} 7862 7863func awsRestxml_deserializeOpErrorListTagsForResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7864 var errorBuffer bytes.Buffer 7865 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7866 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7867 } 7868 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7869 7870 errorCode := "UnknownError" 7871 errorMessage := errorCode 7872 7873 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7874 if err != nil { 7875 return err 7876 } 7877 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7878 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7879 } 7880 if len(errorComponents.Code) != 0 { 7881 errorCode = errorComponents.Code 7882 } 7883 if len(errorComponents.Message) != 0 { 7884 errorMessage = errorComponents.Message 7885 } 7886 errorBody.Seek(0, io.SeekStart) 7887 switch { 7888 case strings.EqualFold("InvalidInput", errorCode): 7889 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 7890 7891 case strings.EqualFold("NoSuchHealthCheck", errorCode): 7892 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 7893 7894 case strings.EqualFold("NoSuchHostedZone", errorCode): 7895 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 7896 7897 case strings.EqualFold("PriorRequestNotComplete", errorCode): 7898 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 7899 7900 case strings.EqualFold("ThrottlingException", errorCode): 7901 return awsRestxml_deserializeErrorThrottlingException(response, errorBody) 7902 7903 default: 7904 genericError := &smithy.GenericAPIError{ 7905 Code: errorCode, 7906 Message: errorMessage, 7907 } 7908 return genericError 7909 7910 } 7911} 7912 7913func awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(v **ListTagsForResourcesOutput, decoder smithyxml.NodeDecoder) error { 7914 if v == nil { 7915 return fmt.Errorf("unexpected nil of type %T", v) 7916 } 7917 var sv *ListTagsForResourcesOutput 7918 if *v == nil { 7919 sv = &ListTagsForResourcesOutput{} 7920 } else { 7921 sv = *v 7922 } 7923 7924 for { 7925 t, done, err := decoder.Token() 7926 if err != nil { 7927 return err 7928 } 7929 if done { 7930 break 7931 } 7932 originalDecoder := decoder 7933 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7934 switch { 7935 case strings.EqualFold("ResourceTagSets", t.Name.Local): 7936 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7937 if err := awsRestxml_deserializeDocumentResourceTagSetList(&sv.ResourceTagSets, nodeDecoder); err != nil { 7938 return err 7939 } 7940 7941 default: 7942 // Do nothing and ignore the unexpected tag element 7943 err = decoder.Decoder.Skip() 7944 if err != nil { 7945 return err 7946 } 7947 7948 } 7949 decoder = originalDecoder 7950 } 7951 *v = sv 7952 return nil 7953} 7954 7955type awsRestxml_deserializeOpListTrafficPolicies struct { 7956} 7957 7958func (*awsRestxml_deserializeOpListTrafficPolicies) ID() string { 7959 return "OperationDeserializer" 7960} 7961 7962func (m *awsRestxml_deserializeOpListTrafficPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7963 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7964) { 7965 out, metadata, err = next.HandleDeserialize(ctx, in) 7966 if err != nil { 7967 return out, metadata, err 7968 } 7969 7970 response, ok := out.RawResponse.(*smithyhttp.Response) 7971 if !ok { 7972 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7973 } 7974 7975 if response.StatusCode < 200 || response.StatusCode >= 300 { 7976 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicies(response, &metadata) 7977 } 7978 output := &ListTrafficPoliciesOutput{} 7979 out.Result = output 7980 7981 var buff [1024]byte 7982 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7983 body := io.TeeReader(response.Body, ringBuffer) 7984 rootDecoder := xml.NewDecoder(body) 7985 t, err := smithyxml.FetchRootElement(rootDecoder) 7986 if err == io.EOF { 7987 return out, metadata, nil 7988 } 7989 if err != nil { 7990 var snapshot bytes.Buffer 7991 io.Copy(&snapshot, ringBuffer) 7992 return out, metadata, &smithy.DeserializationError{ 7993 Err: fmt.Errorf("failed to decode response body, %w", err), 7994 Snapshot: snapshot.Bytes(), 7995 } 7996 } 7997 7998 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7999 err = awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(&output, decoder) 8000 if err != nil { 8001 var snapshot bytes.Buffer 8002 io.Copy(&snapshot, ringBuffer) 8003 return out, metadata, &smithy.DeserializationError{ 8004 Err: fmt.Errorf("failed to decode response body, %w", err), 8005 Snapshot: snapshot.Bytes(), 8006 } 8007 } 8008 8009 return out, metadata, err 8010} 8011 8012func awsRestxml_deserializeOpErrorListTrafficPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8013 var errorBuffer bytes.Buffer 8014 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8015 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8016 } 8017 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8018 8019 errorCode := "UnknownError" 8020 errorMessage := errorCode 8021 8022 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8023 if err != nil { 8024 return err 8025 } 8026 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8027 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8028 } 8029 if len(errorComponents.Code) != 0 { 8030 errorCode = errorComponents.Code 8031 } 8032 if len(errorComponents.Message) != 0 { 8033 errorMessage = errorComponents.Message 8034 } 8035 errorBody.Seek(0, io.SeekStart) 8036 switch { 8037 case strings.EqualFold("InvalidInput", errorCode): 8038 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8039 8040 default: 8041 genericError := &smithy.GenericAPIError{ 8042 Code: errorCode, 8043 Message: errorMessage, 8044 } 8045 return genericError 8046 8047 } 8048} 8049 8050func awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(v **ListTrafficPoliciesOutput, decoder smithyxml.NodeDecoder) error { 8051 if v == nil { 8052 return fmt.Errorf("unexpected nil of type %T", v) 8053 } 8054 var sv *ListTrafficPoliciesOutput 8055 if *v == nil { 8056 sv = &ListTrafficPoliciesOutput{} 8057 } else { 8058 sv = *v 8059 } 8060 8061 for { 8062 t, done, err := decoder.Token() 8063 if err != nil { 8064 return err 8065 } 8066 if done { 8067 break 8068 } 8069 originalDecoder := decoder 8070 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8071 switch { 8072 case strings.EqualFold("IsTruncated", t.Name.Local): 8073 val, err := decoder.Value() 8074 if err != nil { 8075 return err 8076 } 8077 if val == nil { 8078 break 8079 } 8080 { 8081 xtv, err := strconv.ParseBool(string(val)) 8082 if err != nil { 8083 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8084 } 8085 sv.IsTruncated = xtv 8086 } 8087 8088 case strings.EqualFold("MaxItems", t.Name.Local): 8089 val, err := decoder.Value() 8090 if err != nil { 8091 return err 8092 } 8093 if val == nil { 8094 break 8095 } 8096 { 8097 xtv := string(val) 8098 i64, err := strconv.ParseInt(xtv, 10, 64) 8099 if err != nil { 8100 return err 8101 } 8102 sv.MaxItems = ptr.Int32(int32(i64)) 8103 } 8104 8105 case strings.EqualFold("TrafficPolicyIdMarker", t.Name.Local): 8106 val, err := decoder.Value() 8107 if err != nil { 8108 return err 8109 } 8110 if val == nil { 8111 break 8112 } 8113 { 8114 xtv := string(val) 8115 sv.TrafficPolicyIdMarker = ptr.String(xtv) 8116 } 8117 8118 case strings.EqualFold("TrafficPolicySummaries", t.Name.Local): 8119 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8120 if err := awsRestxml_deserializeDocumentTrafficPolicySummaries(&sv.TrafficPolicySummaries, nodeDecoder); err != nil { 8121 return err 8122 } 8123 8124 default: 8125 // Do nothing and ignore the unexpected tag element 8126 err = decoder.Decoder.Skip() 8127 if err != nil { 8128 return err 8129 } 8130 8131 } 8132 decoder = originalDecoder 8133 } 8134 *v = sv 8135 return nil 8136} 8137 8138type awsRestxml_deserializeOpListTrafficPolicyInstances struct { 8139} 8140 8141func (*awsRestxml_deserializeOpListTrafficPolicyInstances) ID() string { 8142 return "OperationDeserializer" 8143} 8144 8145func (m *awsRestxml_deserializeOpListTrafficPolicyInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8146 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8147) { 8148 out, metadata, err = next.HandleDeserialize(ctx, in) 8149 if err != nil { 8150 return out, metadata, err 8151 } 8152 8153 response, ok := out.RawResponse.(*smithyhttp.Response) 8154 if !ok { 8155 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8156 } 8157 8158 if response.StatusCode < 200 || response.StatusCode >= 300 { 8159 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response, &metadata) 8160 } 8161 output := &ListTrafficPolicyInstancesOutput{} 8162 out.Result = output 8163 8164 var buff [1024]byte 8165 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8166 body := io.TeeReader(response.Body, ringBuffer) 8167 rootDecoder := xml.NewDecoder(body) 8168 t, err := smithyxml.FetchRootElement(rootDecoder) 8169 if err == io.EOF { 8170 return out, metadata, nil 8171 } 8172 if err != nil { 8173 var snapshot bytes.Buffer 8174 io.Copy(&snapshot, ringBuffer) 8175 return out, metadata, &smithy.DeserializationError{ 8176 Err: fmt.Errorf("failed to decode response body, %w", err), 8177 Snapshot: snapshot.Bytes(), 8178 } 8179 } 8180 8181 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8182 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(&output, decoder) 8183 if err != nil { 8184 var snapshot bytes.Buffer 8185 io.Copy(&snapshot, ringBuffer) 8186 return out, metadata, &smithy.DeserializationError{ 8187 Err: fmt.Errorf("failed to decode response body, %w", err), 8188 Snapshot: snapshot.Bytes(), 8189 } 8190 } 8191 8192 return out, metadata, err 8193} 8194 8195func awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8196 var errorBuffer bytes.Buffer 8197 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8198 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8199 } 8200 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8201 8202 errorCode := "UnknownError" 8203 errorMessage := errorCode 8204 8205 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8206 if err != nil { 8207 return err 8208 } 8209 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8210 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8211 } 8212 if len(errorComponents.Code) != 0 { 8213 errorCode = errorComponents.Code 8214 } 8215 if len(errorComponents.Message) != 0 { 8216 errorMessage = errorComponents.Message 8217 } 8218 errorBody.Seek(0, io.SeekStart) 8219 switch { 8220 case strings.EqualFold("InvalidInput", errorCode): 8221 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8222 8223 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 8224 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 8225 8226 default: 8227 genericError := &smithy.GenericAPIError{ 8228 Code: errorCode, 8229 Message: errorMessage, 8230 } 8231 return genericError 8232 8233 } 8234} 8235 8236func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(v **ListTrafficPolicyInstancesOutput, decoder smithyxml.NodeDecoder) error { 8237 if v == nil { 8238 return fmt.Errorf("unexpected nil of type %T", v) 8239 } 8240 var sv *ListTrafficPolicyInstancesOutput 8241 if *v == nil { 8242 sv = &ListTrafficPolicyInstancesOutput{} 8243 } else { 8244 sv = *v 8245 } 8246 8247 for { 8248 t, done, err := decoder.Token() 8249 if err != nil { 8250 return err 8251 } 8252 if done { 8253 break 8254 } 8255 originalDecoder := decoder 8256 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8257 switch { 8258 case strings.EqualFold("HostedZoneIdMarker", t.Name.Local): 8259 val, err := decoder.Value() 8260 if err != nil { 8261 return err 8262 } 8263 if val == nil { 8264 break 8265 } 8266 { 8267 xtv := string(val) 8268 sv.HostedZoneIdMarker = ptr.String(xtv) 8269 } 8270 8271 case strings.EqualFold("IsTruncated", t.Name.Local): 8272 val, err := decoder.Value() 8273 if err != nil { 8274 return err 8275 } 8276 if val == nil { 8277 break 8278 } 8279 { 8280 xtv, err := strconv.ParseBool(string(val)) 8281 if err != nil { 8282 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8283 } 8284 sv.IsTruncated = xtv 8285 } 8286 8287 case strings.EqualFold("MaxItems", t.Name.Local): 8288 val, err := decoder.Value() 8289 if err != nil { 8290 return err 8291 } 8292 if val == nil { 8293 break 8294 } 8295 { 8296 xtv := string(val) 8297 i64, err := strconv.ParseInt(xtv, 10, 64) 8298 if err != nil { 8299 return err 8300 } 8301 sv.MaxItems = ptr.Int32(int32(i64)) 8302 } 8303 8304 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local): 8305 val, err := decoder.Value() 8306 if err != nil { 8307 return err 8308 } 8309 if val == nil { 8310 break 8311 } 8312 { 8313 xtv := string(val) 8314 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv) 8315 } 8316 8317 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local): 8318 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8319 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil { 8320 return err 8321 } 8322 8323 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local): 8324 val, err := decoder.Value() 8325 if err != nil { 8326 return err 8327 } 8328 if val == nil { 8329 break 8330 } 8331 { 8332 xtv := string(val) 8333 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv) 8334 } 8335 8336 default: 8337 // Do nothing and ignore the unexpected tag element 8338 err = decoder.Decoder.Skip() 8339 if err != nil { 8340 return err 8341 } 8342 8343 } 8344 decoder = originalDecoder 8345 } 8346 *v = sv 8347 return nil 8348} 8349 8350type awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone struct { 8351} 8352 8353func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) ID() string { 8354 return "OperationDeserializer" 8355} 8356 8357func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8358 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8359) { 8360 out, metadata, err = next.HandleDeserialize(ctx, in) 8361 if err != nil { 8362 return out, metadata, err 8363 } 8364 8365 response, ok := out.RawResponse.(*smithyhttp.Response) 8366 if !ok { 8367 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8368 } 8369 8370 if response.StatusCode < 200 || response.StatusCode >= 300 { 8371 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response, &metadata) 8372 } 8373 output := &ListTrafficPolicyInstancesByHostedZoneOutput{} 8374 out.Result = output 8375 8376 var buff [1024]byte 8377 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8378 body := io.TeeReader(response.Body, ringBuffer) 8379 rootDecoder := xml.NewDecoder(body) 8380 t, err := smithyxml.FetchRootElement(rootDecoder) 8381 if err == io.EOF { 8382 return out, metadata, nil 8383 } 8384 if err != nil { 8385 var snapshot bytes.Buffer 8386 io.Copy(&snapshot, ringBuffer) 8387 return out, metadata, &smithy.DeserializationError{ 8388 Err: fmt.Errorf("failed to decode response body, %w", err), 8389 Snapshot: snapshot.Bytes(), 8390 } 8391 } 8392 8393 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8394 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(&output, decoder) 8395 if err != nil { 8396 var snapshot bytes.Buffer 8397 io.Copy(&snapshot, ringBuffer) 8398 return out, metadata, &smithy.DeserializationError{ 8399 Err: fmt.Errorf("failed to decode response body, %w", err), 8400 Snapshot: snapshot.Bytes(), 8401 } 8402 } 8403 8404 return out, metadata, err 8405} 8406 8407func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8408 var errorBuffer bytes.Buffer 8409 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8410 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8411 } 8412 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8413 8414 errorCode := "UnknownError" 8415 errorMessage := errorCode 8416 8417 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8418 if err != nil { 8419 return err 8420 } 8421 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8422 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8423 } 8424 if len(errorComponents.Code) != 0 { 8425 errorCode = errorComponents.Code 8426 } 8427 if len(errorComponents.Message) != 0 { 8428 errorMessage = errorComponents.Message 8429 } 8430 errorBody.Seek(0, io.SeekStart) 8431 switch { 8432 case strings.EqualFold("InvalidInput", errorCode): 8433 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8434 8435 case strings.EqualFold("NoSuchHostedZone", errorCode): 8436 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 8437 8438 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 8439 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 8440 8441 default: 8442 genericError := &smithy.GenericAPIError{ 8443 Code: errorCode, 8444 Message: errorMessage, 8445 } 8446 return genericError 8447 8448 } 8449} 8450 8451func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(v **ListTrafficPolicyInstancesByHostedZoneOutput, decoder smithyxml.NodeDecoder) error { 8452 if v == nil { 8453 return fmt.Errorf("unexpected nil of type %T", v) 8454 } 8455 var sv *ListTrafficPolicyInstancesByHostedZoneOutput 8456 if *v == nil { 8457 sv = &ListTrafficPolicyInstancesByHostedZoneOutput{} 8458 } else { 8459 sv = *v 8460 } 8461 8462 for { 8463 t, done, err := decoder.Token() 8464 if err != nil { 8465 return err 8466 } 8467 if done { 8468 break 8469 } 8470 originalDecoder := decoder 8471 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8472 switch { 8473 case strings.EqualFold("IsTruncated", t.Name.Local): 8474 val, err := decoder.Value() 8475 if err != nil { 8476 return err 8477 } 8478 if val == nil { 8479 break 8480 } 8481 { 8482 xtv, err := strconv.ParseBool(string(val)) 8483 if err != nil { 8484 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8485 } 8486 sv.IsTruncated = xtv 8487 } 8488 8489 case strings.EqualFold("MaxItems", t.Name.Local): 8490 val, err := decoder.Value() 8491 if err != nil { 8492 return err 8493 } 8494 if val == nil { 8495 break 8496 } 8497 { 8498 xtv := string(val) 8499 i64, err := strconv.ParseInt(xtv, 10, 64) 8500 if err != nil { 8501 return err 8502 } 8503 sv.MaxItems = ptr.Int32(int32(i64)) 8504 } 8505 8506 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local): 8507 val, err := decoder.Value() 8508 if err != nil { 8509 return err 8510 } 8511 if val == nil { 8512 break 8513 } 8514 { 8515 xtv := string(val) 8516 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv) 8517 } 8518 8519 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local): 8520 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8521 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil { 8522 return err 8523 } 8524 8525 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local): 8526 val, err := decoder.Value() 8527 if err != nil { 8528 return err 8529 } 8530 if val == nil { 8531 break 8532 } 8533 { 8534 xtv := string(val) 8535 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv) 8536 } 8537 8538 default: 8539 // Do nothing and ignore the unexpected tag element 8540 err = decoder.Decoder.Skip() 8541 if err != nil { 8542 return err 8543 } 8544 8545 } 8546 decoder = originalDecoder 8547 } 8548 *v = sv 8549 return nil 8550} 8551 8552type awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy struct { 8553} 8554 8555func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) ID() string { 8556 return "OperationDeserializer" 8557} 8558 8559func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8560 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8561) { 8562 out, metadata, err = next.HandleDeserialize(ctx, in) 8563 if err != nil { 8564 return out, metadata, err 8565 } 8566 8567 response, ok := out.RawResponse.(*smithyhttp.Response) 8568 if !ok { 8569 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8570 } 8571 8572 if response.StatusCode < 200 || response.StatusCode >= 300 { 8573 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response, &metadata) 8574 } 8575 output := &ListTrafficPolicyInstancesByPolicyOutput{} 8576 out.Result = output 8577 8578 var buff [1024]byte 8579 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8580 body := io.TeeReader(response.Body, ringBuffer) 8581 rootDecoder := xml.NewDecoder(body) 8582 t, err := smithyxml.FetchRootElement(rootDecoder) 8583 if err == io.EOF { 8584 return out, metadata, nil 8585 } 8586 if err != nil { 8587 var snapshot bytes.Buffer 8588 io.Copy(&snapshot, ringBuffer) 8589 return out, metadata, &smithy.DeserializationError{ 8590 Err: fmt.Errorf("failed to decode response body, %w", err), 8591 Snapshot: snapshot.Bytes(), 8592 } 8593 } 8594 8595 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8596 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(&output, decoder) 8597 if err != nil { 8598 var snapshot bytes.Buffer 8599 io.Copy(&snapshot, ringBuffer) 8600 return out, metadata, &smithy.DeserializationError{ 8601 Err: fmt.Errorf("failed to decode response body, %w", err), 8602 Snapshot: snapshot.Bytes(), 8603 } 8604 } 8605 8606 return out, metadata, err 8607} 8608 8609func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8610 var errorBuffer bytes.Buffer 8611 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8612 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8613 } 8614 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8615 8616 errorCode := "UnknownError" 8617 errorMessage := errorCode 8618 8619 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8620 if err != nil { 8621 return err 8622 } 8623 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8624 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8625 } 8626 if len(errorComponents.Code) != 0 { 8627 errorCode = errorComponents.Code 8628 } 8629 if len(errorComponents.Message) != 0 { 8630 errorMessage = errorComponents.Message 8631 } 8632 errorBody.Seek(0, io.SeekStart) 8633 switch { 8634 case strings.EqualFold("InvalidInput", errorCode): 8635 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8636 8637 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 8638 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 8639 8640 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 8641 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 8642 8643 default: 8644 genericError := &smithy.GenericAPIError{ 8645 Code: errorCode, 8646 Message: errorMessage, 8647 } 8648 return genericError 8649 8650 } 8651} 8652 8653func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(v **ListTrafficPolicyInstancesByPolicyOutput, decoder smithyxml.NodeDecoder) error { 8654 if v == nil { 8655 return fmt.Errorf("unexpected nil of type %T", v) 8656 } 8657 var sv *ListTrafficPolicyInstancesByPolicyOutput 8658 if *v == nil { 8659 sv = &ListTrafficPolicyInstancesByPolicyOutput{} 8660 } else { 8661 sv = *v 8662 } 8663 8664 for { 8665 t, done, err := decoder.Token() 8666 if err != nil { 8667 return err 8668 } 8669 if done { 8670 break 8671 } 8672 originalDecoder := decoder 8673 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8674 switch { 8675 case strings.EqualFold("HostedZoneIdMarker", t.Name.Local): 8676 val, err := decoder.Value() 8677 if err != nil { 8678 return err 8679 } 8680 if val == nil { 8681 break 8682 } 8683 { 8684 xtv := string(val) 8685 sv.HostedZoneIdMarker = ptr.String(xtv) 8686 } 8687 8688 case strings.EqualFold("IsTruncated", t.Name.Local): 8689 val, err := decoder.Value() 8690 if err != nil { 8691 return err 8692 } 8693 if val == nil { 8694 break 8695 } 8696 { 8697 xtv, err := strconv.ParseBool(string(val)) 8698 if err != nil { 8699 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8700 } 8701 sv.IsTruncated = xtv 8702 } 8703 8704 case strings.EqualFold("MaxItems", t.Name.Local): 8705 val, err := decoder.Value() 8706 if err != nil { 8707 return err 8708 } 8709 if val == nil { 8710 break 8711 } 8712 { 8713 xtv := string(val) 8714 i64, err := strconv.ParseInt(xtv, 10, 64) 8715 if err != nil { 8716 return err 8717 } 8718 sv.MaxItems = ptr.Int32(int32(i64)) 8719 } 8720 8721 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local): 8722 val, err := decoder.Value() 8723 if err != nil { 8724 return err 8725 } 8726 if val == nil { 8727 break 8728 } 8729 { 8730 xtv := string(val) 8731 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv) 8732 } 8733 8734 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local): 8735 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8736 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil { 8737 return err 8738 } 8739 8740 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local): 8741 val, err := decoder.Value() 8742 if err != nil { 8743 return err 8744 } 8745 if val == nil { 8746 break 8747 } 8748 { 8749 xtv := string(val) 8750 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv) 8751 } 8752 8753 default: 8754 // Do nothing and ignore the unexpected tag element 8755 err = decoder.Decoder.Skip() 8756 if err != nil { 8757 return err 8758 } 8759 8760 } 8761 decoder = originalDecoder 8762 } 8763 *v = sv 8764 return nil 8765} 8766 8767type awsRestxml_deserializeOpListTrafficPolicyVersions struct { 8768} 8769 8770func (*awsRestxml_deserializeOpListTrafficPolicyVersions) ID() string { 8771 return "OperationDeserializer" 8772} 8773 8774func (m *awsRestxml_deserializeOpListTrafficPolicyVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8775 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8776) { 8777 out, metadata, err = next.HandleDeserialize(ctx, in) 8778 if err != nil { 8779 return out, metadata, err 8780 } 8781 8782 response, ok := out.RawResponse.(*smithyhttp.Response) 8783 if !ok { 8784 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8785 } 8786 8787 if response.StatusCode < 200 || response.StatusCode >= 300 { 8788 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response, &metadata) 8789 } 8790 output := &ListTrafficPolicyVersionsOutput{} 8791 out.Result = output 8792 8793 var buff [1024]byte 8794 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8795 body := io.TeeReader(response.Body, ringBuffer) 8796 rootDecoder := xml.NewDecoder(body) 8797 t, err := smithyxml.FetchRootElement(rootDecoder) 8798 if err == io.EOF { 8799 return out, metadata, nil 8800 } 8801 if err != nil { 8802 var snapshot bytes.Buffer 8803 io.Copy(&snapshot, ringBuffer) 8804 return out, metadata, &smithy.DeserializationError{ 8805 Err: fmt.Errorf("failed to decode response body, %w", err), 8806 Snapshot: snapshot.Bytes(), 8807 } 8808 } 8809 8810 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8811 err = awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(&output, decoder) 8812 if err != nil { 8813 var snapshot bytes.Buffer 8814 io.Copy(&snapshot, ringBuffer) 8815 return out, metadata, &smithy.DeserializationError{ 8816 Err: fmt.Errorf("failed to decode response body, %w", err), 8817 Snapshot: snapshot.Bytes(), 8818 } 8819 } 8820 8821 return out, metadata, err 8822} 8823 8824func awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8825 var errorBuffer bytes.Buffer 8826 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8827 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8828 } 8829 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8830 8831 errorCode := "UnknownError" 8832 errorMessage := errorCode 8833 8834 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 8835 if err != nil { 8836 return err 8837 } 8838 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8839 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8840 } 8841 if len(errorComponents.Code) != 0 { 8842 errorCode = errorComponents.Code 8843 } 8844 if len(errorComponents.Message) != 0 { 8845 errorMessage = errorComponents.Message 8846 } 8847 errorBody.Seek(0, io.SeekStart) 8848 switch { 8849 case strings.EqualFold("InvalidInput", errorCode): 8850 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 8851 8852 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 8853 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 8854 8855 default: 8856 genericError := &smithy.GenericAPIError{ 8857 Code: errorCode, 8858 Message: errorMessage, 8859 } 8860 return genericError 8861 8862 } 8863} 8864 8865func awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(v **ListTrafficPolicyVersionsOutput, decoder smithyxml.NodeDecoder) error { 8866 if v == nil { 8867 return fmt.Errorf("unexpected nil of type %T", v) 8868 } 8869 var sv *ListTrafficPolicyVersionsOutput 8870 if *v == nil { 8871 sv = &ListTrafficPolicyVersionsOutput{} 8872 } else { 8873 sv = *v 8874 } 8875 8876 for { 8877 t, done, err := decoder.Token() 8878 if err != nil { 8879 return err 8880 } 8881 if done { 8882 break 8883 } 8884 originalDecoder := decoder 8885 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8886 switch { 8887 case strings.EqualFold("IsTruncated", t.Name.Local): 8888 val, err := decoder.Value() 8889 if err != nil { 8890 return err 8891 } 8892 if val == nil { 8893 break 8894 } 8895 { 8896 xtv, err := strconv.ParseBool(string(val)) 8897 if err != nil { 8898 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val) 8899 } 8900 sv.IsTruncated = xtv 8901 } 8902 8903 case strings.EqualFold("MaxItems", t.Name.Local): 8904 val, err := decoder.Value() 8905 if err != nil { 8906 return err 8907 } 8908 if val == nil { 8909 break 8910 } 8911 { 8912 xtv := string(val) 8913 i64, err := strconv.ParseInt(xtv, 10, 64) 8914 if err != nil { 8915 return err 8916 } 8917 sv.MaxItems = ptr.Int32(int32(i64)) 8918 } 8919 8920 case strings.EqualFold("TrafficPolicies", t.Name.Local): 8921 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8922 if err := awsRestxml_deserializeDocumentTrafficPolicies(&sv.TrafficPolicies, nodeDecoder); err != nil { 8923 return err 8924 } 8925 8926 case strings.EqualFold("TrafficPolicyVersionMarker", t.Name.Local): 8927 val, err := decoder.Value() 8928 if err != nil { 8929 return err 8930 } 8931 if val == nil { 8932 break 8933 } 8934 { 8935 xtv := string(val) 8936 sv.TrafficPolicyVersionMarker = ptr.String(xtv) 8937 } 8938 8939 default: 8940 // Do nothing and ignore the unexpected tag element 8941 err = decoder.Decoder.Skip() 8942 if err != nil { 8943 return err 8944 } 8945 8946 } 8947 decoder = originalDecoder 8948 } 8949 *v = sv 8950 return nil 8951} 8952 8953type awsRestxml_deserializeOpListVPCAssociationAuthorizations struct { 8954} 8955 8956func (*awsRestxml_deserializeOpListVPCAssociationAuthorizations) ID() string { 8957 return "OperationDeserializer" 8958} 8959 8960func (m *awsRestxml_deserializeOpListVPCAssociationAuthorizations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8961 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8962) { 8963 out, metadata, err = next.HandleDeserialize(ctx, in) 8964 if err != nil { 8965 return out, metadata, err 8966 } 8967 8968 response, ok := out.RawResponse.(*smithyhttp.Response) 8969 if !ok { 8970 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8971 } 8972 8973 if response.StatusCode < 200 || response.StatusCode >= 300 { 8974 return out, metadata, awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response, &metadata) 8975 } 8976 output := &ListVPCAssociationAuthorizationsOutput{} 8977 out.Result = output 8978 8979 var buff [1024]byte 8980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8981 body := io.TeeReader(response.Body, ringBuffer) 8982 rootDecoder := xml.NewDecoder(body) 8983 t, err := smithyxml.FetchRootElement(rootDecoder) 8984 if err == io.EOF { 8985 return out, metadata, nil 8986 } 8987 if err != nil { 8988 var snapshot bytes.Buffer 8989 io.Copy(&snapshot, ringBuffer) 8990 return out, metadata, &smithy.DeserializationError{ 8991 Err: fmt.Errorf("failed to decode response body, %w", err), 8992 Snapshot: snapshot.Bytes(), 8993 } 8994 } 8995 8996 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8997 err = awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(&output, decoder) 8998 if err != nil { 8999 var snapshot bytes.Buffer 9000 io.Copy(&snapshot, ringBuffer) 9001 return out, metadata, &smithy.DeserializationError{ 9002 Err: fmt.Errorf("failed to decode response body, %w", err), 9003 Snapshot: snapshot.Bytes(), 9004 } 9005 } 9006 9007 return out, metadata, err 9008} 9009 9010func awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9011 var errorBuffer bytes.Buffer 9012 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9013 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9014 } 9015 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9016 9017 errorCode := "UnknownError" 9018 errorMessage := errorCode 9019 9020 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9021 if err != nil { 9022 return err 9023 } 9024 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9025 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9026 } 9027 if len(errorComponents.Code) != 0 { 9028 errorCode = errorComponents.Code 9029 } 9030 if len(errorComponents.Message) != 0 { 9031 errorMessage = errorComponents.Message 9032 } 9033 errorBody.Seek(0, io.SeekStart) 9034 switch { 9035 case strings.EqualFold("InvalidInput", errorCode): 9036 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9037 9038 case strings.EqualFold("InvalidPaginationToken", errorCode): 9039 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody) 9040 9041 case strings.EqualFold("NoSuchHostedZone", errorCode): 9042 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 9043 9044 default: 9045 genericError := &smithy.GenericAPIError{ 9046 Code: errorCode, 9047 Message: errorMessage, 9048 } 9049 return genericError 9050 9051 } 9052} 9053 9054func awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(v **ListVPCAssociationAuthorizationsOutput, decoder smithyxml.NodeDecoder) error { 9055 if v == nil { 9056 return fmt.Errorf("unexpected nil of type %T", v) 9057 } 9058 var sv *ListVPCAssociationAuthorizationsOutput 9059 if *v == nil { 9060 sv = &ListVPCAssociationAuthorizationsOutput{} 9061 } else { 9062 sv = *v 9063 } 9064 9065 for { 9066 t, done, err := decoder.Token() 9067 if err != nil { 9068 return err 9069 } 9070 if done { 9071 break 9072 } 9073 originalDecoder := decoder 9074 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9075 switch { 9076 case strings.EqualFold("HostedZoneId", t.Name.Local): 9077 val, err := decoder.Value() 9078 if err != nil { 9079 return err 9080 } 9081 if val == nil { 9082 break 9083 } 9084 { 9085 xtv := string(val) 9086 sv.HostedZoneId = ptr.String(xtv) 9087 } 9088 9089 case strings.EqualFold("NextToken", t.Name.Local): 9090 val, err := decoder.Value() 9091 if err != nil { 9092 return err 9093 } 9094 if val == nil { 9095 break 9096 } 9097 { 9098 xtv := string(val) 9099 sv.NextToken = ptr.String(xtv) 9100 } 9101 9102 case strings.EqualFold("VPCs", t.Name.Local): 9103 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9104 if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil { 9105 return err 9106 } 9107 9108 default: 9109 // Do nothing and ignore the unexpected tag element 9110 err = decoder.Decoder.Skip() 9111 if err != nil { 9112 return err 9113 } 9114 9115 } 9116 decoder = originalDecoder 9117 } 9118 *v = sv 9119 return nil 9120} 9121 9122type awsRestxml_deserializeOpTestDNSAnswer struct { 9123} 9124 9125func (*awsRestxml_deserializeOpTestDNSAnswer) ID() string { 9126 return "OperationDeserializer" 9127} 9128 9129func (m *awsRestxml_deserializeOpTestDNSAnswer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9130 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9131) { 9132 out, metadata, err = next.HandleDeserialize(ctx, in) 9133 if err != nil { 9134 return out, metadata, err 9135 } 9136 9137 response, ok := out.RawResponse.(*smithyhttp.Response) 9138 if !ok { 9139 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9140 } 9141 9142 if response.StatusCode < 200 || response.StatusCode >= 300 { 9143 return out, metadata, awsRestxml_deserializeOpErrorTestDNSAnswer(response, &metadata) 9144 } 9145 output := &TestDNSAnswerOutput{} 9146 out.Result = output 9147 9148 var buff [1024]byte 9149 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9150 body := io.TeeReader(response.Body, ringBuffer) 9151 rootDecoder := xml.NewDecoder(body) 9152 t, err := smithyxml.FetchRootElement(rootDecoder) 9153 if err == io.EOF { 9154 return out, metadata, nil 9155 } 9156 if err != nil { 9157 var snapshot bytes.Buffer 9158 io.Copy(&snapshot, ringBuffer) 9159 return out, metadata, &smithy.DeserializationError{ 9160 Err: fmt.Errorf("failed to decode response body, %w", err), 9161 Snapshot: snapshot.Bytes(), 9162 } 9163 } 9164 9165 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9166 err = awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(&output, decoder) 9167 if err != nil { 9168 var snapshot bytes.Buffer 9169 io.Copy(&snapshot, ringBuffer) 9170 return out, metadata, &smithy.DeserializationError{ 9171 Err: fmt.Errorf("failed to decode response body, %w", err), 9172 Snapshot: snapshot.Bytes(), 9173 } 9174 } 9175 9176 return out, metadata, err 9177} 9178 9179func awsRestxml_deserializeOpErrorTestDNSAnswer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9180 var errorBuffer bytes.Buffer 9181 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9182 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9183 } 9184 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9185 9186 errorCode := "UnknownError" 9187 errorMessage := errorCode 9188 9189 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9190 if err != nil { 9191 return err 9192 } 9193 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9194 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9195 } 9196 if len(errorComponents.Code) != 0 { 9197 errorCode = errorComponents.Code 9198 } 9199 if len(errorComponents.Message) != 0 { 9200 errorMessage = errorComponents.Message 9201 } 9202 errorBody.Seek(0, io.SeekStart) 9203 switch { 9204 case strings.EqualFold("InvalidInput", errorCode): 9205 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9206 9207 case strings.EqualFold("NoSuchHostedZone", errorCode): 9208 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 9209 9210 default: 9211 genericError := &smithy.GenericAPIError{ 9212 Code: errorCode, 9213 Message: errorMessage, 9214 } 9215 return genericError 9216 9217 } 9218} 9219 9220func awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(v **TestDNSAnswerOutput, decoder smithyxml.NodeDecoder) error { 9221 if v == nil { 9222 return fmt.Errorf("unexpected nil of type %T", v) 9223 } 9224 var sv *TestDNSAnswerOutput 9225 if *v == nil { 9226 sv = &TestDNSAnswerOutput{} 9227 } else { 9228 sv = *v 9229 } 9230 9231 for { 9232 t, done, err := decoder.Token() 9233 if err != nil { 9234 return err 9235 } 9236 if done { 9237 break 9238 } 9239 originalDecoder := decoder 9240 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9241 switch { 9242 case strings.EqualFold("Nameserver", t.Name.Local): 9243 val, err := decoder.Value() 9244 if err != nil { 9245 return err 9246 } 9247 if val == nil { 9248 break 9249 } 9250 { 9251 xtv := string(val) 9252 sv.Nameserver = ptr.String(xtv) 9253 } 9254 9255 case strings.EqualFold("Protocol", t.Name.Local): 9256 val, err := decoder.Value() 9257 if err != nil { 9258 return err 9259 } 9260 if val == nil { 9261 break 9262 } 9263 { 9264 xtv := string(val) 9265 sv.Protocol = ptr.String(xtv) 9266 } 9267 9268 case strings.EqualFold("RecordData", t.Name.Local): 9269 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9270 if err := awsRestxml_deserializeDocumentRecordData(&sv.RecordData, nodeDecoder); err != nil { 9271 return err 9272 } 9273 9274 case strings.EqualFold("RecordName", t.Name.Local): 9275 val, err := decoder.Value() 9276 if err != nil { 9277 return err 9278 } 9279 if val == nil { 9280 break 9281 } 9282 { 9283 xtv := string(val) 9284 sv.RecordName = ptr.String(xtv) 9285 } 9286 9287 case strings.EqualFold("RecordType", t.Name.Local): 9288 val, err := decoder.Value() 9289 if err != nil { 9290 return err 9291 } 9292 if val == nil { 9293 break 9294 } 9295 { 9296 xtv := string(val) 9297 sv.RecordType = types.RRType(xtv) 9298 } 9299 9300 case strings.EqualFold("ResponseCode", t.Name.Local): 9301 val, err := decoder.Value() 9302 if err != nil { 9303 return err 9304 } 9305 if val == nil { 9306 break 9307 } 9308 { 9309 xtv := string(val) 9310 sv.ResponseCode = ptr.String(xtv) 9311 } 9312 9313 default: 9314 // Do nothing and ignore the unexpected tag element 9315 err = decoder.Decoder.Skip() 9316 if err != nil { 9317 return err 9318 } 9319 9320 } 9321 decoder = originalDecoder 9322 } 9323 *v = sv 9324 return nil 9325} 9326 9327type awsRestxml_deserializeOpUpdateHealthCheck struct { 9328} 9329 9330func (*awsRestxml_deserializeOpUpdateHealthCheck) ID() string { 9331 return "OperationDeserializer" 9332} 9333 9334func (m *awsRestxml_deserializeOpUpdateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9335 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9336) { 9337 out, metadata, err = next.HandleDeserialize(ctx, in) 9338 if err != nil { 9339 return out, metadata, err 9340 } 9341 9342 response, ok := out.RawResponse.(*smithyhttp.Response) 9343 if !ok { 9344 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9345 } 9346 9347 if response.StatusCode < 200 || response.StatusCode >= 300 { 9348 return out, metadata, awsRestxml_deserializeOpErrorUpdateHealthCheck(response, &metadata) 9349 } 9350 output := &UpdateHealthCheckOutput{} 9351 out.Result = output 9352 9353 var buff [1024]byte 9354 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9355 body := io.TeeReader(response.Body, ringBuffer) 9356 rootDecoder := xml.NewDecoder(body) 9357 t, err := smithyxml.FetchRootElement(rootDecoder) 9358 if err == io.EOF { 9359 return out, metadata, nil 9360 } 9361 if err != nil { 9362 var snapshot bytes.Buffer 9363 io.Copy(&snapshot, ringBuffer) 9364 return out, metadata, &smithy.DeserializationError{ 9365 Err: fmt.Errorf("failed to decode response body, %w", err), 9366 Snapshot: snapshot.Bytes(), 9367 } 9368 } 9369 9370 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9371 err = awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(&output, decoder) 9372 if err != nil { 9373 var snapshot bytes.Buffer 9374 io.Copy(&snapshot, ringBuffer) 9375 return out, metadata, &smithy.DeserializationError{ 9376 Err: fmt.Errorf("failed to decode response body, %w", err), 9377 Snapshot: snapshot.Bytes(), 9378 } 9379 } 9380 9381 return out, metadata, err 9382} 9383 9384func awsRestxml_deserializeOpErrorUpdateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9385 var errorBuffer bytes.Buffer 9386 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9387 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9388 } 9389 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9390 9391 errorCode := "UnknownError" 9392 errorMessage := errorCode 9393 9394 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9395 if err != nil { 9396 return err 9397 } 9398 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9399 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9400 } 9401 if len(errorComponents.Code) != 0 { 9402 errorCode = errorComponents.Code 9403 } 9404 if len(errorComponents.Message) != 0 { 9405 errorMessage = errorComponents.Message 9406 } 9407 errorBody.Seek(0, io.SeekStart) 9408 switch { 9409 case strings.EqualFold("HealthCheckVersionMismatch", errorCode): 9410 return awsRestxml_deserializeErrorHealthCheckVersionMismatch(response, errorBody) 9411 9412 case strings.EqualFold("InvalidInput", errorCode): 9413 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9414 9415 case strings.EqualFold("NoSuchHealthCheck", errorCode): 9416 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody) 9417 9418 default: 9419 genericError := &smithy.GenericAPIError{ 9420 Code: errorCode, 9421 Message: errorMessage, 9422 } 9423 return genericError 9424 9425 } 9426} 9427 9428func awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(v **UpdateHealthCheckOutput, decoder smithyxml.NodeDecoder) error { 9429 if v == nil { 9430 return fmt.Errorf("unexpected nil of type %T", v) 9431 } 9432 var sv *UpdateHealthCheckOutput 9433 if *v == nil { 9434 sv = &UpdateHealthCheckOutput{} 9435 } else { 9436 sv = *v 9437 } 9438 9439 for { 9440 t, done, err := decoder.Token() 9441 if err != nil { 9442 return err 9443 } 9444 if done { 9445 break 9446 } 9447 originalDecoder := decoder 9448 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9449 switch { 9450 case strings.EqualFold("HealthCheck", t.Name.Local): 9451 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9452 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil { 9453 return err 9454 } 9455 9456 default: 9457 // Do nothing and ignore the unexpected tag element 9458 err = decoder.Decoder.Skip() 9459 if err != nil { 9460 return err 9461 } 9462 9463 } 9464 decoder = originalDecoder 9465 } 9466 *v = sv 9467 return nil 9468} 9469 9470type awsRestxml_deserializeOpUpdateHostedZoneComment struct { 9471} 9472 9473func (*awsRestxml_deserializeOpUpdateHostedZoneComment) ID() string { 9474 return "OperationDeserializer" 9475} 9476 9477func (m *awsRestxml_deserializeOpUpdateHostedZoneComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9478 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9479) { 9480 out, metadata, err = next.HandleDeserialize(ctx, in) 9481 if err != nil { 9482 return out, metadata, err 9483 } 9484 9485 response, ok := out.RawResponse.(*smithyhttp.Response) 9486 if !ok { 9487 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9488 } 9489 9490 if response.StatusCode < 200 || response.StatusCode >= 300 { 9491 return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response, &metadata) 9492 } 9493 output := &UpdateHostedZoneCommentOutput{} 9494 out.Result = output 9495 9496 var buff [1024]byte 9497 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9498 body := io.TeeReader(response.Body, ringBuffer) 9499 rootDecoder := xml.NewDecoder(body) 9500 t, err := smithyxml.FetchRootElement(rootDecoder) 9501 if err == io.EOF { 9502 return out, metadata, nil 9503 } 9504 if err != nil { 9505 var snapshot bytes.Buffer 9506 io.Copy(&snapshot, ringBuffer) 9507 return out, metadata, &smithy.DeserializationError{ 9508 Err: fmt.Errorf("failed to decode response body, %w", err), 9509 Snapshot: snapshot.Bytes(), 9510 } 9511 } 9512 9513 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9514 err = awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(&output, decoder) 9515 if err != nil { 9516 var snapshot bytes.Buffer 9517 io.Copy(&snapshot, ringBuffer) 9518 return out, metadata, &smithy.DeserializationError{ 9519 Err: fmt.Errorf("failed to decode response body, %w", err), 9520 Snapshot: snapshot.Bytes(), 9521 } 9522 } 9523 9524 return out, metadata, err 9525} 9526 9527func awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9528 var errorBuffer bytes.Buffer 9529 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9530 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9531 } 9532 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9533 9534 errorCode := "UnknownError" 9535 errorMessage := errorCode 9536 9537 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9538 if err != nil { 9539 return err 9540 } 9541 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9542 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9543 } 9544 if len(errorComponents.Code) != 0 { 9545 errorCode = errorComponents.Code 9546 } 9547 if len(errorComponents.Message) != 0 { 9548 errorMessage = errorComponents.Message 9549 } 9550 errorBody.Seek(0, io.SeekStart) 9551 switch { 9552 case strings.EqualFold("InvalidInput", errorCode): 9553 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9554 9555 case strings.EqualFold("NoSuchHostedZone", errorCode): 9556 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody) 9557 9558 default: 9559 genericError := &smithy.GenericAPIError{ 9560 Code: errorCode, 9561 Message: errorMessage, 9562 } 9563 return genericError 9564 9565 } 9566} 9567 9568func awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(v **UpdateHostedZoneCommentOutput, decoder smithyxml.NodeDecoder) error { 9569 if v == nil { 9570 return fmt.Errorf("unexpected nil of type %T", v) 9571 } 9572 var sv *UpdateHostedZoneCommentOutput 9573 if *v == nil { 9574 sv = &UpdateHostedZoneCommentOutput{} 9575 } else { 9576 sv = *v 9577 } 9578 9579 for { 9580 t, done, err := decoder.Token() 9581 if err != nil { 9582 return err 9583 } 9584 if done { 9585 break 9586 } 9587 originalDecoder := decoder 9588 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9589 switch { 9590 case strings.EqualFold("HostedZone", t.Name.Local): 9591 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9592 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil { 9593 return err 9594 } 9595 9596 default: 9597 // Do nothing and ignore the unexpected tag element 9598 err = decoder.Decoder.Skip() 9599 if err != nil { 9600 return err 9601 } 9602 9603 } 9604 decoder = originalDecoder 9605 } 9606 *v = sv 9607 return nil 9608} 9609 9610type awsRestxml_deserializeOpUpdateTrafficPolicyComment struct { 9611} 9612 9613func (*awsRestxml_deserializeOpUpdateTrafficPolicyComment) ID() string { 9614 return "OperationDeserializer" 9615} 9616 9617func (m *awsRestxml_deserializeOpUpdateTrafficPolicyComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9619) { 9620 out, metadata, err = next.HandleDeserialize(ctx, in) 9621 if err != nil { 9622 return out, metadata, err 9623 } 9624 9625 response, ok := out.RawResponse.(*smithyhttp.Response) 9626 if !ok { 9627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9628 } 9629 9630 if response.StatusCode < 200 || response.StatusCode >= 300 { 9631 return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response, &metadata) 9632 } 9633 output := &UpdateTrafficPolicyCommentOutput{} 9634 out.Result = output 9635 9636 var buff [1024]byte 9637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9638 body := io.TeeReader(response.Body, ringBuffer) 9639 rootDecoder := xml.NewDecoder(body) 9640 t, err := smithyxml.FetchRootElement(rootDecoder) 9641 if err == io.EOF { 9642 return out, metadata, nil 9643 } 9644 if err != nil { 9645 var snapshot bytes.Buffer 9646 io.Copy(&snapshot, ringBuffer) 9647 return out, metadata, &smithy.DeserializationError{ 9648 Err: fmt.Errorf("failed to decode response body, %w", err), 9649 Snapshot: snapshot.Bytes(), 9650 } 9651 } 9652 9653 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9654 err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(&output, decoder) 9655 if err != nil { 9656 var snapshot bytes.Buffer 9657 io.Copy(&snapshot, ringBuffer) 9658 return out, metadata, &smithy.DeserializationError{ 9659 Err: fmt.Errorf("failed to decode response body, %w", err), 9660 Snapshot: snapshot.Bytes(), 9661 } 9662 } 9663 9664 return out, metadata, err 9665} 9666 9667func awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9668 var errorBuffer bytes.Buffer 9669 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9670 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9671 } 9672 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9673 9674 errorCode := "UnknownError" 9675 errorMessage := errorCode 9676 9677 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9678 if err != nil { 9679 return err 9680 } 9681 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9682 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9683 } 9684 if len(errorComponents.Code) != 0 { 9685 errorCode = errorComponents.Code 9686 } 9687 if len(errorComponents.Message) != 0 { 9688 errorMessage = errorComponents.Message 9689 } 9690 errorBody.Seek(0, io.SeekStart) 9691 switch { 9692 case strings.EqualFold("ConcurrentModification", errorCode): 9693 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody) 9694 9695 case strings.EqualFold("InvalidInput", errorCode): 9696 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9697 9698 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 9699 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 9700 9701 default: 9702 genericError := &smithy.GenericAPIError{ 9703 Code: errorCode, 9704 Message: errorMessage, 9705 } 9706 return genericError 9707 9708 } 9709} 9710 9711func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(v **UpdateTrafficPolicyCommentOutput, decoder smithyxml.NodeDecoder) error { 9712 if v == nil { 9713 return fmt.Errorf("unexpected nil of type %T", v) 9714 } 9715 var sv *UpdateTrafficPolicyCommentOutput 9716 if *v == nil { 9717 sv = &UpdateTrafficPolicyCommentOutput{} 9718 } else { 9719 sv = *v 9720 } 9721 9722 for { 9723 t, done, err := decoder.Token() 9724 if err != nil { 9725 return err 9726 } 9727 if done { 9728 break 9729 } 9730 originalDecoder := decoder 9731 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9732 switch { 9733 case strings.EqualFold("TrafficPolicy", t.Name.Local): 9734 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9735 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil { 9736 return err 9737 } 9738 9739 default: 9740 // Do nothing and ignore the unexpected tag element 9741 err = decoder.Decoder.Skip() 9742 if err != nil { 9743 return err 9744 } 9745 9746 } 9747 decoder = originalDecoder 9748 } 9749 *v = sv 9750 return nil 9751} 9752 9753type awsRestxml_deserializeOpUpdateTrafficPolicyInstance struct { 9754} 9755 9756func (*awsRestxml_deserializeOpUpdateTrafficPolicyInstance) ID() string { 9757 return "OperationDeserializer" 9758} 9759 9760func (m *awsRestxml_deserializeOpUpdateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9761 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9762) { 9763 out, metadata, err = next.HandleDeserialize(ctx, in) 9764 if err != nil { 9765 return out, metadata, err 9766 } 9767 9768 response, ok := out.RawResponse.(*smithyhttp.Response) 9769 if !ok { 9770 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9771 } 9772 9773 if response.StatusCode < 200 || response.StatusCode >= 300 { 9774 return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response, &metadata) 9775 } 9776 output := &UpdateTrafficPolicyInstanceOutput{} 9777 out.Result = output 9778 9779 var buff [1024]byte 9780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9781 body := io.TeeReader(response.Body, ringBuffer) 9782 rootDecoder := xml.NewDecoder(body) 9783 t, err := smithyxml.FetchRootElement(rootDecoder) 9784 if err == io.EOF { 9785 return out, metadata, nil 9786 } 9787 if err != nil { 9788 var snapshot bytes.Buffer 9789 io.Copy(&snapshot, ringBuffer) 9790 return out, metadata, &smithy.DeserializationError{ 9791 Err: fmt.Errorf("failed to decode response body, %w", err), 9792 Snapshot: snapshot.Bytes(), 9793 } 9794 } 9795 9796 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9797 err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(&output, decoder) 9798 if err != nil { 9799 var snapshot bytes.Buffer 9800 io.Copy(&snapshot, ringBuffer) 9801 return out, metadata, &smithy.DeserializationError{ 9802 Err: fmt.Errorf("failed to decode response body, %w", err), 9803 Snapshot: snapshot.Bytes(), 9804 } 9805 } 9806 9807 return out, metadata, err 9808} 9809 9810func awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9811 var errorBuffer bytes.Buffer 9812 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9813 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9814 } 9815 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9816 9817 errorCode := "UnknownError" 9818 errorMessage := errorCode 9819 9820 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 9821 if err != nil { 9822 return err 9823 } 9824 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9825 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9826 } 9827 if len(errorComponents.Code) != 0 { 9828 errorCode = errorComponents.Code 9829 } 9830 if len(errorComponents.Message) != 0 { 9831 errorMessage = errorComponents.Message 9832 } 9833 errorBody.Seek(0, io.SeekStart) 9834 switch { 9835 case strings.EqualFold("ConflictingTypes", errorCode): 9836 return awsRestxml_deserializeErrorConflictingTypes(response, errorBody) 9837 9838 case strings.EqualFold("InvalidInput", errorCode): 9839 return awsRestxml_deserializeErrorInvalidInput(response, errorBody) 9840 9841 case strings.EqualFold("NoSuchTrafficPolicy", errorCode): 9842 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody) 9843 9844 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode): 9845 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody) 9846 9847 case strings.EqualFold("PriorRequestNotComplete", errorCode): 9848 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody) 9849 9850 default: 9851 genericError := &smithy.GenericAPIError{ 9852 Code: errorCode, 9853 Message: errorMessage, 9854 } 9855 return genericError 9856 9857 } 9858} 9859 9860func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(v **UpdateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error { 9861 if v == nil { 9862 return fmt.Errorf("unexpected nil of type %T", v) 9863 } 9864 var sv *UpdateTrafficPolicyInstanceOutput 9865 if *v == nil { 9866 sv = &UpdateTrafficPolicyInstanceOutput{} 9867 } else { 9868 sv = *v 9869 } 9870 9871 for { 9872 t, done, err := decoder.Token() 9873 if err != nil { 9874 return err 9875 } 9876 if done { 9877 break 9878 } 9879 originalDecoder := decoder 9880 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9881 switch { 9882 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 9883 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9884 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil { 9885 return err 9886 } 9887 9888 default: 9889 // Do nothing and ignore the unexpected tag element 9890 err = decoder.Decoder.Skip() 9891 if err != nil { 9892 return err 9893 } 9894 9895 } 9896 decoder = originalDecoder 9897 } 9898 *v = sv 9899 return nil 9900} 9901 9902func awsRestxml_deserializeErrorConcurrentModification(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9903 output := &types.ConcurrentModification{} 9904 var buff [1024]byte 9905 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9906 body := io.TeeReader(errorBody, ringBuffer) 9907 rootDecoder := xml.NewDecoder(body) 9908 t, err := smithyxml.FetchRootElement(rootDecoder) 9909 if err == io.EOF { 9910 return output 9911 } 9912 if err != nil { 9913 var snapshot bytes.Buffer 9914 io.Copy(&snapshot, ringBuffer) 9915 return &smithy.DeserializationError{ 9916 Err: fmt.Errorf("failed to decode response body, %w", err), 9917 Snapshot: snapshot.Bytes(), 9918 } 9919 } 9920 9921 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9922 t, err = decoder.GetElement("Error") 9923 if err != nil { 9924 var snapshot bytes.Buffer 9925 io.Copy(&snapshot, ringBuffer) 9926 return &smithy.DeserializationError{ 9927 Err: fmt.Errorf("failed to decode response body, %w", err), 9928 Snapshot: snapshot.Bytes(), 9929 } 9930 } 9931 9932 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9933 err = awsRestxml_deserializeDocumentConcurrentModification(&output, decoder) 9934 if err != nil { 9935 var snapshot bytes.Buffer 9936 io.Copy(&snapshot, ringBuffer) 9937 return &smithy.DeserializationError{ 9938 Err: fmt.Errorf("failed to decode response body, %w", err), 9939 Snapshot: snapshot.Bytes(), 9940 } 9941 } 9942 9943 return output 9944} 9945 9946func awsRestxml_deserializeErrorConflictingDomainExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9947 output := &types.ConflictingDomainExists{} 9948 var buff [1024]byte 9949 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9950 body := io.TeeReader(errorBody, ringBuffer) 9951 rootDecoder := xml.NewDecoder(body) 9952 t, err := smithyxml.FetchRootElement(rootDecoder) 9953 if err == io.EOF { 9954 return output 9955 } 9956 if err != nil { 9957 var snapshot bytes.Buffer 9958 io.Copy(&snapshot, ringBuffer) 9959 return &smithy.DeserializationError{ 9960 Err: fmt.Errorf("failed to decode response body, %w", err), 9961 Snapshot: snapshot.Bytes(), 9962 } 9963 } 9964 9965 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9966 t, err = decoder.GetElement("Error") 9967 if err != nil { 9968 var snapshot bytes.Buffer 9969 io.Copy(&snapshot, ringBuffer) 9970 return &smithy.DeserializationError{ 9971 Err: fmt.Errorf("failed to decode response body, %w", err), 9972 Snapshot: snapshot.Bytes(), 9973 } 9974 } 9975 9976 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9977 err = awsRestxml_deserializeDocumentConflictingDomainExists(&output, decoder) 9978 if err != nil { 9979 var snapshot bytes.Buffer 9980 io.Copy(&snapshot, ringBuffer) 9981 return &smithy.DeserializationError{ 9982 Err: fmt.Errorf("failed to decode response body, %w", err), 9983 Snapshot: snapshot.Bytes(), 9984 } 9985 } 9986 9987 return output 9988} 9989 9990func awsRestxml_deserializeErrorConflictingTypes(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9991 output := &types.ConflictingTypes{} 9992 var buff [1024]byte 9993 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9994 body := io.TeeReader(errorBody, ringBuffer) 9995 rootDecoder := xml.NewDecoder(body) 9996 t, err := smithyxml.FetchRootElement(rootDecoder) 9997 if err == io.EOF { 9998 return output 9999 } 10000 if err != nil { 10001 var snapshot bytes.Buffer 10002 io.Copy(&snapshot, ringBuffer) 10003 return &smithy.DeserializationError{ 10004 Err: fmt.Errorf("failed to decode response body, %w", err), 10005 Snapshot: snapshot.Bytes(), 10006 } 10007 } 10008 10009 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10010 t, err = decoder.GetElement("Error") 10011 if err != nil { 10012 var snapshot bytes.Buffer 10013 io.Copy(&snapshot, ringBuffer) 10014 return &smithy.DeserializationError{ 10015 Err: fmt.Errorf("failed to decode response body, %w", err), 10016 Snapshot: snapshot.Bytes(), 10017 } 10018 } 10019 10020 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10021 err = awsRestxml_deserializeDocumentConflictingTypes(&output, decoder) 10022 if err != nil { 10023 var snapshot bytes.Buffer 10024 io.Copy(&snapshot, ringBuffer) 10025 return &smithy.DeserializationError{ 10026 Err: fmt.Errorf("failed to decode response body, %w", err), 10027 Snapshot: snapshot.Bytes(), 10028 } 10029 } 10030 10031 return output 10032} 10033 10034func awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10035 output := &types.DelegationSetAlreadyCreated{} 10036 var buff [1024]byte 10037 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10038 body := io.TeeReader(errorBody, ringBuffer) 10039 rootDecoder := xml.NewDecoder(body) 10040 t, err := smithyxml.FetchRootElement(rootDecoder) 10041 if err == io.EOF { 10042 return output 10043 } 10044 if err != nil { 10045 var snapshot bytes.Buffer 10046 io.Copy(&snapshot, ringBuffer) 10047 return &smithy.DeserializationError{ 10048 Err: fmt.Errorf("failed to decode response body, %w", err), 10049 Snapshot: snapshot.Bytes(), 10050 } 10051 } 10052 10053 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10054 t, err = decoder.GetElement("Error") 10055 if err != nil { 10056 var snapshot bytes.Buffer 10057 io.Copy(&snapshot, ringBuffer) 10058 return &smithy.DeserializationError{ 10059 Err: fmt.Errorf("failed to decode response body, %w", err), 10060 Snapshot: snapshot.Bytes(), 10061 } 10062 } 10063 10064 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10065 err = awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(&output, decoder) 10066 if err != nil { 10067 var snapshot bytes.Buffer 10068 io.Copy(&snapshot, ringBuffer) 10069 return &smithy.DeserializationError{ 10070 Err: fmt.Errorf("failed to decode response body, %w", err), 10071 Snapshot: snapshot.Bytes(), 10072 } 10073 } 10074 10075 return output 10076} 10077 10078func awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10079 output := &types.DelegationSetAlreadyReusable{} 10080 var buff [1024]byte 10081 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10082 body := io.TeeReader(errorBody, ringBuffer) 10083 rootDecoder := xml.NewDecoder(body) 10084 t, err := smithyxml.FetchRootElement(rootDecoder) 10085 if err == io.EOF { 10086 return output 10087 } 10088 if err != nil { 10089 var snapshot bytes.Buffer 10090 io.Copy(&snapshot, ringBuffer) 10091 return &smithy.DeserializationError{ 10092 Err: fmt.Errorf("failed to decode response body, %w", err), 10093 Snapshot: snapshot.Bytes(), 10094 } 10095 } 10096 10097 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10098 t, err = decoder.GetElement("Error") 10099 if err != nil { 10100 var snapshot bytes.Buffer 10101 io.Copy(&snapshot, ringBuffer) 10102 return &smithy.DeserializationError{ 10103 Err: fmt.Errorf("failed to decode response body, %w", err), 10104 Snapshot: snapshot.Bytes(), 10105 } 10106 } 10107 10108 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10109 err = awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(&output, decoder) 10110 if err != nil { 10111 var snapshot bytes.Buffer 10112 io.Copy(&snapshot, ringBuffer) 10113 return &smithy.DeserializationError{ 10114 Err: fmt.Errorf("failed to decode response body, %w", err), 10115 Snapshot: snapshot.Bytes(), 10116 } 10117 } 10118 10119 return output 10120} 10121 10122func awsRestxml_deserializeErrorDelegationSetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10123 output := &types.DelegationSetInUse{} 10124 var buff [1024]byte 10125 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10126 body := io.TeeReader(errorBody, ringBuffer) 10127 rootDecoder := xml.NewDecoder(body) 10128 t, err := smithyxml.FetchRootElement(rootDecoder) 10129 if err == io.EOF { 10130 return output 10131 } 10132 if err != nil { 10133 var snapshot bytes.Buffer 10134 io.Copy(&snapshot, ringBuffer) 10135 return &smithy.DeserializationError{ 10136 Err: fmt.Errorf("failed to decode response body, %w", err), 10137 Snapshot: snapshot.Bytes(), 10138 } 10139 } 10140 10141 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10142 t, err = decoder.GetElement("Error") 10143 if err != nil { 10144 var snapshot bytes.Buffer 10145 io.Copy(&snapshot, ringBuffer) 10146 return &smithy.DeserializationError{ 10147 Err: fmt.Errorf("failed to decode response body, %w", err), 10148 Snapshot: snapshot.Bytes(), 10149 } 10150 } 10151 10152 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10153 err = awsRestxml_deserializeDocumentDelegationSetInUse(&output, decoder) 10154 if err != nil { 10155 var snapshot bytes.Buffer 10156 io.Copy(&snapshot, ringBuffer) 10157 return &smithy.DeserializationError{ 10158 Err: fmt.Errorf("failed to decode response body, %w", err), 10159 Snapshot: snapshot.Bytes(), 10160 } 10161 } 10162 10163 return output 10164} 10165 10166func awsRestxml_deserializeErrorDelegationSetNotAvailable(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10167 output := &types.DelegationSetNotAvailable{} 10168 var buff [1024]byte 10169 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10170 body := io.TeeReader(errorBody, ringBuffer) 10171 rootDecoder := xml.NewDecoder(body) 10172 t, err := smithyxml.FetchRootElement(rootDecoder) 10173 if err == io.EOF { 10174 return output 10175 } 10176 if err != nil { 10177 var snapshot bytes.Buffer 10178 io.Copy(&snapshot, ringBuffer) 10179 return &smithy.DeserializationError{ 10180 Err: fmt.Errorf("failed to decode response body, %w", err), 10181 Snapshot: snapshot.Bytes(), 10182 } 10183 } 10184 10185 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10186 t, err = decoder.GetElement("Error") 10187 if err != nil { 10188 var snapshot bytes.Buffer 10189 io.Copy(&snapshot, ringBuffer) 10190 return &smithy.DeserializationError{ 10191 Err: fmt.Errorf("failed to decode response body, %w", err), 10192 Snapshot: snapshot.Bytes(), 10193 } 10194 } 10195 10196 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10197 err = awsRestxml_deserializeDocumentDelegationSetNotAvailable(&output, decoder) 10198 if err != nil { 10199 var snapshot bytes.Buffer 10200 io.Copy(&snapshot, ringBuffer) 10201 return &smithy.DeserializationError{ 10202 Err: fmt.Errorf("failed to decode response body, %w", err), 10203 Snapshot: snapshot.Bytes(), 10204 } 10205 } 10206 10207 return output 10208} 10209 10210func awsRestxml_deserializeErrorDelegationSetNotReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10211 output := &types.DelegationSetNotReusable{} 10212 var buff [1024]byte 10213 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10214 body := io.TeeReader(errorBody, ringBuffer) 10215 rootDecoder := xml.NewDecoder(body) 10216 t, err := smithyxml.FetchRootElement(rootDecoder) 10217 if err == io.EOF { 10218 return output 10219 } 10220 if err != nil { 10221 var snapshot bytes.Buffer 10222 io.Copy(&snapshot, ringBuffer) 10223 return &smithy.DeserializationError{ 10224 Err: fmt.Errorf("failed to decode response body, %w", err), 10225 Snapshot: snapshot.Bytes(), 10226 } 10227 } 10228 10229 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10230 t, err = decoder.GetElement("Error") 10231 if err != nil { 10232 var snapshot bytes.Buffer 10233 io.Copy(&snapshot, ringBuffer) 10234 return &smithy.DeserializationError{ 10235 Err: fmt.Errorf("failed to decode response body, %w", err), 10236 Snapshot: snapshot.Bytes(), 10237 } 10238 } 10239 10240 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10241 err = awsRestxml_deserializeDocumentDelegationSetNotReusable(&output, decoder) 10242 if err != nil { 10243 var snapshot bytes.Buffer 10244 io.Copy(&snapshot, ringBuffer) 10245 return &smithy.DeserializationError{ 10246 Err: fmt.Errorf("failed to decode response body, %w", err), 10247 Snapshot: snapshot.Bytes(), 10248 } 10249 } 10250 10251 return output 10252} 10253 10254func awsRestxml_deserializeErrorDNSSECNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10255 output := &types.DNSSECNotFound{} 10256 var buff [1024]byte 10257 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10258 body := io.TeeReader(errorBody, ringBuffer) 10259 rootDecoder := xml.NewDecoder(body) 10260 t, err := smithyxml.FetchRootElement(rootDecoder) 10261 if err == io.EOF { 10262 return output 10263 } 10264 if err != nil { 10265 var snapshot bytes.Buffer 10266 io.Copy(&snapshot, ringBuffer) 10267 return &smithy.DeserializationError{ 10268 Err: fmt.Errorf("failed to decode response body, %w", err), 10269 Snapshot: snapshot.Bytes(), 10270 } 10271 } 10272 10273 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10274 t, err = decoder.GetElement("Error") 10275 if err != nil { 10276 var snapshot bytes.Buffer 10277 io.Copy(&snapshot, ringBuffer) 10278 return &smithy.DeserializationError{ 10279 Err: fmt.Errorf("failed to decode response body, %w", err), 10280 Snapshot: snapshot.Bytes(), 10281 } 10282 } 10283 10284 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10285 err = awsRestxml_deserializeDocumentDNSSECNotFound(&output, decoder) 10286 if err != nil { 10287 var snapshot bytes.Buffer 10288 io.Copy(&snapshot, ringBuffer) 10289 return &smithy.DeserializationError{ 10290 Err: fmt.Errorf("failed to decode response body, %w", err), 10291 Snapshot: snapshot.Bytes(), 10292 } 10293 } 10294 10295 return output 10296} 10297 10298func awsRestxml_deserializeErrorHealthCheckAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10299 output := &types.HealthCheckAlreadyExists{} 10300 var buff [1024]byte 10301 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10302 body := io.TeeReader(errorBody, ringBuffer) 10303 rootDecoder := xml.NewDecoder(body) 10304 t, err := smithyxml.FetchRootElement(rootDecoder) 10305 if err == io.EOF { 10306 return output 10307 } 10308 if err != nil { 10309 var snapshot bytes.Buffer 10310 io.Copy(&snapshot, ringBuffer) 10311 return &smithy.DeserializationError{ 10312 Err: fmt.Errorf("failed to decode response body, %w", err), 10313 Snapshot: snapshot.Bytes(), 10314 } 10315 } 10316 10317 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10318 t, err = decoder.GetElement("Error") 10319 if err != nil { 10320 var snapshot bytes.Buffer 10321 io.Copy(&snapshot, ringBuffer) 10322 return &smithy.DeserializationError{ 10323 Err: fmt.Errorf("failed to decode response body, %w", err), 10324 Snapshot: snapshot.Bytes(), 10325 } 10326 } 10327 10328 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10329 err = awsRestxml_deserializeDocumentHealthCheckAlreadyExists(&output, decoder) 10330 if err != nil { 10331 var snapshot bytes.Buffer 10332 io.Copy(&snapshot, ringBuffer) 10333 return &smithy.DeserializationError{ 10334 Err: fmt.Errorf("failed to decode response body, %w", err), 10335 Snapshot: snapshot.Bytes(), 10336 } 10337 } 10338 10339 return output 10340} 10341 10342func awsRestxml_deserializeErrorHealthCheckInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10343 output := &types.HealthCheckInUse{} 10344 var buff [1024]byte 10345 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10346 body := io.TeeReader(errorBody, ringBuffer) 10347 rootDecoder := xml.NewDecoder(body) 10348 t, err := smithyxml.FetchRootElement(rootDecoder) 10349 if err == io.EOF { 10350 return output 10351 } 10352 if err != nil { 10353 var snapshot bytes.Buffer 10354 io.Copy(&snapshot, ringBuffer) 10355 return &smithy.DeserializationError{ 10356 Err: fmt.Errorf("failed to decode response body, %w", err), 10357 Snapshot: snapshot.Bytes(), 10358 } 10359 } 10360 10361 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10362 t, err = decoder.GetElement("Error") 10363 if err != nil { 10364 var snapshot bytes.Buffer 10365 io.Copy(&snapshot, ringBuffer) 10366 return &smithy.DeserializationError{ 10367 Err: fmt.Errorf("failed to decode response body, %w", err), 10368 Snapshot: snapshot.Bytes(), 10369 } 10370 } 10371 10372 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10373 err = awsRestxml_deserializeDocumentHealthCheckInUse(&output, decoder) 10374 if err != nil { 10375 var snapshot bytes.Buffer 10376 io.Copy(&snapshot, ringBuffer) 10377 return &smithy.DeserializationError{ 10378 Err: fmt.Errorf("failed to decode response body, %w", err), 10379 Snapshot: snapshot.Bytes(), 10380 } 10381 } 10382 10383 return output 10384} 10385 10386func awsRestxml_deserializeErrorHealthCheckVersionMismatch(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10387 output := &types.HealthCheckVersionMismatch{} 10388 var buff [1024]byte 10389 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10390 body := io.TeeReader(errorBody, ringBuffer) 10391 rootDecoder := xml.NewDecoder(body) 10392 t, err := smithyxml.FetchRootElement(rootDecoder) 10393 if err == io.EOF { 10394 return output 10395 } 10396 if err != nil { 10397 var snapshot bytes.Buffer 10398 io.Copy(&snapshot, ringBuffer) 10399 return &smithy.DeserializationError{ 10400 Err: fmt.Errorf("failed to decode response body, %w", err), 10401 Snapshot: snapshot.Bytes(), 10402 } 10403 } 10404 10405 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10406 t, err = decoder.GetElement("Error") 10407 if err != nil { 10408 var snapshot bytes.Buffer 10409 io.Copy(&snapshot, ringBuffer) 10410 return &smithy.DeserializationError{ 10411 Err: fmt.Errorf("failed to decode response body, %w", err), 10412 Snapshot: snapshot.Bytes(), 10413 } 10414 } 10415 10416 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10417 err = awsRestxml_deserializeDocumentHealthCheckVersionMismatch(&output, decoder) 10418 if err != nil { 10419 var snapshot bytes.Buffer 10420 io.Copy(&snapshot, ringBuffer) 10421 return &smithy.DeserializationError{ 10422 Err: fmt.Errorf("failed to decode response body, %w", err), 10423 Snapshot: snapshot.Bytes(), 10424 } 10425 } 10426 10427 return output 10428} 10429 10430func awsRestxml_deserializeErrorHostedZoneAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10431 output := &types.HostedZoneAlreadyExists{} 10432 var buff [1024]byte 10433 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10434 body := io.TeeReader(errorBody, ringBuffer) 10435 rootDecoder := xml.NewDecoder(body) 10436 t, err := smithyxml.FetchRootElement(rootDecoder) 10437 if err == io.EOF { 10438 return output 10439 } 10440 if err != nil { 10441 var snapshot bytes.Buffer 10442 io.Copy(&snapshot, ringBuffer) 10443 return &smithy.DeserializationError{ 10444 Err: fmt.Errorf("failed to decode response body, %w", err), 10445 Snapshot: snapshot.Bytes(), 10446 } 10447 } 10448 10449 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10450 t, err = decoder.GetElement("Error") 10451 if err != nil { 10452 var snapshot bytes.Buffer 10453 io.Copy(&snapshot, ringBuffer) 10454 return &smithy.DeserializationError{ 10455 Err: fmt.Errorf("failed to decode response body, %w", err), 10456 Snapshot: snapshot.Bytes(), 10457 } 10458 } 10459 10460 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10461 err = awsRestxml_deserializeDocumentHostedZoneAlreadyExists(&output, decoder) 10462 if err != nil { 10463 var snapshot bytes.Buffer 10464 io.Copy(&snapshot, ringBuffer) 10465 return &smithy.DeserializationError{ 10466 Err: fmt.Errorf("failed to decode response body, %w", err), 10467 Snapshot: snapshot.Bytes(), 10468 } 10469 } 10470 10471 return output 10472} 10473 10474func awsRestxml_deserializeErrorHostedZoneNotEmpty(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10475 output := &types.HostedZoneNotEmpty{} 10476 var buff [1024]byte 10477 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10478 body := io.TeeReader(errorBody, ringBuffer) 10479 rootDecoder := xml.NewDecoder(body) 10480 t, err := smithyxml.FetchRootElement(rootDecoder) 10481 if err == io.EOF { 10482 return output 10483 } 10484 if err != nil { 10485 var snapshot bytes.Buffer 10486 io.Copy(&snapshot, ringBuffer) 10487 return &smithy.DeserializationError{ 10488 Err: fmt.Errorf("failed to decode response body, %w", err), 10489 Snapshot: snapshot.Bytes(), 10490 } 10491 } 10492 10493 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10494 t, err = decoder.GetElement("Error") 10495 if err != nil { 10496 var snapshot bytes.Buffer 10497 io.Copy(&snapshot, ringBuffer) 10498 return &smithy.DeserializationError{ 10499 Err: fmt.Errorf("failed to decode response body, %w", err), 10500 Snapshot: snapshot.Bytes(), 10501 } 10502 } 10503 10504 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10505 err = awsRestxml_deserializeDocumentHostedZoneNotEmpty(&output, decoder) 10506 if err != nil { 10507 var snapshot bytes.Buffer 10508 io.Copy(&snapshot, ringBuffer) 10509 return &smithy.DeserializationError{ 10510 Err: fmt.Errorf("failed to decode response body, %w", err), 10511 Snapshot: snapshot.Bytes(), 10512 } 10513 } 10514 10515 return output 10516} 10517 10518func awsRestxml_deserializeErrorHostedZoneNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10519 output := &types.HostedZoneNotFound{} 10520 var buff [1024]byte 10521 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10522 body := io.TeeReader(errorBody, ringBuffer) 10523 rootDecoder := xml.NewDecoder(body) 10524 t, err := smithyxml.FetchRootElement(rootDecoder) 10525 if err == io.EOF { 10526 return output 10527 } 10528 if err != nil { 10529 var snapshot bytes.Buffer 10530 io.Copy(&snapshot, ringBuffer) 10531 return &smithy.DeserializationError{ 10532 Err: fmt.Errorf("failed to decode response body, %w", err), 10533 Snapshot: snapshot.Bytes(), 10534 } 10535 } 10536 10537 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10538 t, err = decoder.GetElement("Error") 10539 if err != nil { 10540 var snapshot bytes.Buffer 10541 io.Copy(&snapshot, ringBuffer) 10542 return &smithy.DeserializationError{ 10543 Err: fmt.Errorf("failed to decode response body, %w", err), 10544 Snapshot: snapshot.Bytes(), 10545 } 10546 } 10547 10548 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10549 err = awsRestxml_deserializeDocumentHostedZoneNotFound(&output, decoder) 10550 if err != nil { 10551 var snapshot bytes.Buffer 10552 io.Copy(&snapshot, ringBuffer) 10553 return &smithy.DeserializationError{ 10554 Err: fmt.Errorf("failed to decode response body, %w", err), 10555 Snapshot: snapshot.Bytes(), 10556 } 10557 } 10558 10559 return output 10560} 10561 10562func awsRestxml_deserializeErrorHostedZoneNotPrivate(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10563 output := &types.HostedZoneNotPrivate{} 10564 var buff [1024]byte 10565 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10566 body := io.TeeReader(errorBody, ringBuffer) 10567 rootDecoder := xml.NewDecoder(body) 10568 t, err := smithyxml.FetchRootElement(rootDecoder) 10569 if err == io.EOF { 10570 return output 10571 } 10572 if err != nil { 10573 var snapshot bytes.Buffer 10574 io.Copy(&snapshot, ringBuffer) 10575 return &smithy.DeserializationError{ 10576 Err: fmt.Errorf("failed to decode response body, %w", err), 10577 Snapshot: snapshot.Bytes(), 10578 } 10579 } 10580 10581 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10582 t, err = decoder.GetElement("Error") 10583 if err != nil { 10584 var snapshot bytes.Buffer 10585 io.Copy(&snapshot, ringBuffer) 10586 return &smithy.DeserializationError{ 10587 Err: fmt.Errorf("failed to decode response body, %w", err), 10588 Snapshot: snapshot.Bytes(), 10589 } 10590 } 10591 10592 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10593 err = awsRestxml_deserializeDocumentHostedZoneNotPrivate(&output, decoder) 10594 if err != nil { 10595 var snapshot bytes.Buffer 10596 io.Copy(&snapshot, ringBuffer) 10597 return &smithy.DeserializationError{ 10598 Err: fmt.Errorf("failed to decode response body, %w", err), 10599 Snapshot: snapshot.Bytes(), 10600 } 10601 } 10602 10603 return output 10604} 10605 10606func awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10607 output := &types.HostedZonePartiallyDelegated{} 10608 var buff [1024]byte 10609 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10610 body := io.TeeReader(errorBody, ringBuffer) 10611 rootDecoder := xml.NewDecoder(body) 10612 t, err := smithyxml.FetchRootElement(rootDecoder) 10613 if err == io.EOF { 10614 return output 10615 } 10616 if err != nil { 10617 var snapshot bytes.Buffer 10618 io.Copy(&snapshot, ringBuffer) 10619 return &smithy.DeserializationError{ 10620 Err: fmt.Errorf("failed to decode response body, %w", err), 10621 Snapshot: snapshot.Bytes(), 10622 } 10623 } 10624 10625 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10626 t, err = decoder.GetElement("Error") 10627 if err != nil { 10628 var snapshot bytes.Buffer 10629 io.Copy(&snapshot, ringBuffer) 10630 return &smithy.DeserializationError{ 10631 Err: fmt.Errorf("failed to decode response body, %w", err), 10632 Snapshot: snapshot.Bytes(), 10633 } 10634 } 10635 10636 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10637 err = awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(&output, decoder) 10638 if err != nil { 10639 var snapshot bytes.Buffer 10640 io.Copy(&snapshot, ringBuffer) 10641 return &smithy.DeserializationError{ 10642 Err: fmt.Errorf("failed to decode response body, %w", err), 10643 Snapshot: snapshot.Bytes(), 10644 } 10645 } 10646 10647 return output 10648} 10649 10650func awsRestxml_deserializeErrorIncompatibleVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10651 output := &types.IncompatibleVersion{} 10652 var buff [1024]byte 10653 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10654 body := io.TeeReader(errorBody, ringBuffer) 10655 rootDecoder := xml.NewDecoder(body) 10656 t, err := smithyxml.FetchRootElement(rootDecoder) 10657 if err == io.EOF { 10658 return output 10659 } 10660 if err != nil { 10661 var snapshot bytes.Buffer 10662 io.Copy(&snapshot, ringBuffer) 10663 return &smithy.DeserializationError{ 10664 Err: fmt.Errorf("failed to decode response body, %w", err), 10665 Snapshot: snapshot.Bytes(), 10666 } 10667 } 10668 10669 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10670 t, err = decoder.GetElement("Error") 10671 if err != nil { 10672 var snapshot bytes.Buffer 10673 io.Copy(&snapshot, ringBuffer) 10674 return &smithy.DeserializationError{ 10675 Err: fmt.Errorf("failed to decode response body, %w", err), 10676 Snapshot: snapshot.Bytes(), 10677 } 10678 } 10679 10680 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10681 err = awsRestxml_deserializeDocumentIncompatibleVersion(&output, decoder) 10682 if err != nil { 10683 var snapshot bytes.Buffer 10684 io.Copy(&snapshot, ringBuffer) 10685 return &smithy.DeserializationError{ 10686 Err: fmt.Errorf("failed to decode response body, %w", err), 10687 Snapshot: snapshot.Bytes(), 10688 } 10689 } 10690 10691 return output 10692} 10693 10694func awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10695 output := &types.InsufficientCloudWatchLogsResourcePolicy{} 10696 var buff [1024]byte 10697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10698 body := io.TeeReader(errorBody, ringBuffer) 10699 rootDecoder := xml.NewDecoder(body) 10700 t, err := smithyxml.FetchRootElement(rootDecoder) 10701 if err == io.EOF { 10702 return output 10703 } 10704 if err != nil { 10705 var snapshot bytes.Buffer 10706 io.Copy(&snapshot, ringBuffer) 10707 return &smithy.DeserializationError{ 10708 Err: fmt.Errorf("failed to decode response body, %w", err), 10709 Snapshot: snapshot.Bytes(), 10710 } 10711 } 10712 10713 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10714 t, err = decoder.GetElement("Error") 10715 if err != nil { 10716 var snapshot bytes.Buffer 10717 io.Copy(&snapshot, ringBuffer) 10718 return &smithy.DeserializationError{ 10719 Err: fmt.Errorf("failed to decode response body, %w", err), 10720 Snapshot: snapshot.Bytes(), 10721 } 10722 } 10723 10724 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10725 err = awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(&output, decoder) 10726 if err != nil { 10727 var snapshot bytes.Buffer 10728 io.Copy(&snapshot, ringBuffer) 10729 return &smithy.DeserializationError{ 10730 Err: fmt.Errorf("failed to decode response body, %w", err), 10731 Snapshot: snapshot.Bytes(), 10732 } 10733 } 10734 10735 return output 10736} 10737 10738func awsRestxml_deserializeErrorInvalidArgument(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10739 output := &types.InvalidArgument{} 10740 var buff [1024]byte 10741 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10742 body := io.TeeReader(errorBody, ringBuffer) 10743 rootDecoder := xml.NewDecoder(body) 10744 t, err := smithyxml.FetchRootElement(rootDecoder) 10745 if err == io.EOF { 10746 return output 10747 } 10748 if err != nil { 10749 var snapshot bytes.Buffer 10750 io.Copy(&snapshot, ringBuffer) 10751 return &smithy.DeserializationError{ 10752 Err: fmt.Errorf("failed to decode response body, %w", err), 10753 Snapshot: snapshot.Bytes(), 10754 } 10755 } 10756 10757 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10758 t, err = decoder.GetElement("Error") 10759 if err != nil { 10760 var snapshot bytes.Buffer 10761 io.Copy(&snapshot, ringBuffer) 10762 return &smithy.DeserializationError{ 10763 Err: fmt.Errorf("failed to decode response body, %w", err), 10764 Snapshot: snapshot.Bytes(), 10765 } 10766 } 10767 10768 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10769 err = awsRestxml_deserializeDocumentInvalidArgument(&output, decoder) 10770 if err != nil { 10771 var snapshot bytes.Buffer 10772 io.Copy(&snapshot, ringBuffer) 10773 return &smithy.DeserializationError{ 10774 Err: fmt.Errorf("failed to decode response body, %w", err), 10775 Snapshot: snapshot.Bytes(), 10776 } 10777 } 10778 10779 return output 10780} 10781 10782func awsRestxml_deserializeErrorInvalidChangeBatch(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10783 output := &types.InvalidChangeBatch{} 10784 var buff [1024]byte 10785 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10786 body := io.TeeReader(errorBody, ringBuffer) 10787 rootDecoder := xml.NewDecoder(body) 10788 t, err := smithyxml.FetchRootElement(rootDecoder) 10789 if err == io.EOF { 10790 return output 10791 } 10792 if err != nil { 10793 var snapshot bytes.Buffer 10794 io.Copy(&snapshot, ringBuffer) 10795 return &smithy.DeserializationError{ 10796 Err: fmt.Errorf("failed to decode response body, %w", err), 10797 Snapshot: snapshot.Bytes(), 10798 } 10799 } 10800 10801 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10802 t, err = decoder.GetElement("Error") 10803 if err != nil { 10804 var snapshot bytes.Buffer 10805 io.Copy(&snapshot, ringBuffer) 10806 return &smithy.DeserializationError{ 10807 Err: fmt.Errorf("failed to decode response body, %w", err), 10808 Snapshot: snapshot.Bytes(), 10809 } 10810 } 10811 10812 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10813 err = awsRestxml_deserializeDocumentInvalidChangeBatch(&output, decoder) 10814 if err != nil { 10815 var snapshot bytes.Buffer 10816 io.Copy(&snapshot, ringBuffer) 10817 return &smithy.DeserializationError{ 10818 Err: fmt.Errorf("failed to decode response body, %w", err), 10819 Snapshot: snapshot.Bytes(), 10820 } 10821 } 10822 10823 return output 10824} 10825 10826func awsRestxml_deserializeErrorInvalidDomainName(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10827 output := &types.InvalidDomainName{} 10828 var buff [1024]byte 10829 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10830 body := io.TeeReader(errorBody, ringBuffer) 10831 rootDecoder := xml.NewDecoder(body) 10832 t, err := smithyxml.FetchRootElement(rootDecoder) 10833 if err == io.EOF { 10834 return output 10835 } 10836 if err != nil { 10837 var snapshot bytes.Buffer 10838 io.Copy(&snapshot, ringBuffer) 10839 return &smithy.DeserializationError{ 10840 Err: fmt.Errorf("failed to decode response body, %w", err), 10841 Snapshot: snapshot.Bytes(), 10842 } 10843 } 10844 10845 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10846 t, err = decoder.GetElement("Error") 10847 if err != nil { 10848 var snapshot bytes.Buffer 10849 io.Copy(&snapshot, ringBuffer) 10850 return &smithy.DeserializationError{ 10851 Err: fmt.Errorf("failed to decode response body, %w", err), 10852 Snapshot: snapshot.Bytes(), 10853 } 10854 } 10855 10856 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10857 err = awsRestxml_deserializeDocumentInvalidDomainName(&output, decoder) 10858 if err != nil { 10859 var snapshot bytes.Buffer 10860 io.Copy(&snapshot, ringBuffer) 10861 return &smithy.DeserializationError{ 10862 Err: fmt.Errorf("failed to decode response body, %w", err), 10863 Snapshot: snapshot.Bytes(), 10864 } 10865 } 10866 10867 return output 10868} 10869 10870func awsRestxml_deserializeErrorInvalidInput(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10871 output := &types.InvalidInput{} 10872 var buff [1024]byte 10873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10874 body := io.TeeReader(errorBody, ringBuffer) 10875 rootDecoder := xml.NewDecoder(body) 10876 t, err := smithyxml.FetchRootElement(rootDecoder) 10877 if err == io.EOF { 10878 return output 10879 } 10880 if err != nil { 10881 var snapshot bytes.Buffer 10882 io.Copy(&snapshot, ringBuffer) 10883 return &smithy.DeserializationError{ 10884 Err: fmt.Errorf("failed to decode response body, %w", err), 10885 Snapshot: snapshot.Bytes(), 10886 } 10887 } 10888 10889 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10890 t, err = decoder.GetElement("Error") 10891 if err != nil { 10892 var snapshot bytes.Buffer 10893 io.Copy(&snapshot, ringBuffer) 10894 return &smithy.DeserializationError{ 10895 Err: fmt.Errorf("failed to decode response body, %w", err), 10896 Snapshot: snapshot.Bytes(), 10897 } 10898 } 10899 10900 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10901 err = awsRestxml_deserializeDocumentInvalidInput(&output, decoder) 10902 if err != nil { 10903 var snapshot bytes.Buffer 10904 io.Copy(&snapshot, ringBuffer) 10905 return &smithy.DeserializationError{ 10906 Err: fmt.Errorf("failed to decode response body, %w", err), 10907 Snapshot: snapshot.Bytes(), 10908 } 10909 } 10910 10911 return output 10912} 10913 10914func awsRestxml_deserializeErrorInvalidKeySigningKeyName(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10915 output := &types.InvalidKeySigningKeyName{} 10916 var buff [1024]byte 10917 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10918 body := io.TeeReader(errorBody, ringBuffer) 10919 rootDecoder := xml.NewDecoder(body) 10920 t, err := smithyxml.FetchRootElement(rootDecoder) 10921 if err == io.EOF { 10922 return output 10923 } 10924 if err != nil { 10925 var snapshot bytes.Buffer 10926 io.Copy(&snapshot, ringBuffer) 10927 return &smithy.DeserializationError{ 10928 Err: fmt.Errorf("failed to decode response body, %w", err), 10929 Snapshot: snapshot.Bytes(), 10930 } 10931 } 10932 10933 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10934 t, err = decoder.GetElement("Error") 10935 if err != nil { 10936 var snapshot bytes.Buffer 10937 io.Copy(&snapshot, ringBuffer) 10938 return &smithy.DeserializationError{ 10939 Err: fmt.Errorf("failed to decode response body, %w", err), 10940 Snapshot: snapshot.Bytes(), 10941 } 10942 } 10943 10944 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10945 err = awsRestxml_deserializeDocumentInvalidKeySigningKeyName(&output, decoder) 10946 if err != nil { 10947 var snapshot bytes.Buffer 10948 io.Copy(&snapshot, ringBuffer) 10949 return &smithy.DeserializationError{ 10950 Err: fmt.Errorf("failed to decode response body, %w", err), 10951 Snapshot: snapshot.Bytes(), 10952 } 10953 } 10954 10955 return output 10956} 10957 10958func awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10959 output := &types.InvalidKeySigningKeyStatus{} 10960 var buff [1024]byte 10961 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10962 body := io.TeeReader(errorBody, ringBuffer) 10963 rootDecoder := xml.NewDecoder(body) 10964 t, err := smithyxml.FetchRootElement(rootDecoder) 10965 if err == io.EOF { 10966 return output 10967 } 10968 if err != nil { 10969 var snapshot bytes.Buffer 10970 io.Copy(&snapshot, ringBuffer) 10971 return &smithy.DeserializationError{ 10972 Err: fmt.Errorf("failed to decode response body, %w", err), 10973 Snapshot: snapshot.Bytes(), 10974 } 10975 } 10976 10977 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 10978 t, err = decoder.GetElement("Error") 10979 if err != nil { 10980 var snapshot bytes.Buffer 10981 io.Copy(&snapshot, ringBuffer) 10982 return &smithy.DeserializationError{ 10983 Err: fmt.Errorf("failed to decode response body, %w", err), 10984 Snapshot: snapshot.Bytes(), 10985 } 10986 } 10987 10988 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10989 err = awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(&output, decoder) 10990 if err != nil { 10991 var snapshot bytes.Buffer 10992 io.Copy(&snapshot, ringBuffer) 10993 return &smithy.DeserializationError{ 10994 Err: fmt.Errorf("failed to decode response body, %w", err), 10995 Snapshot: snapshot.Bytes(), 10996 } 10997 } 10998 10999 return output 11000} 11001 11002func awsRestxml_deserializeErrorInvalidKMSArn(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11003 output := &types.InvalidKMSArn{} 11004 var buff [1024]byte 11005 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11006 body := io.TeeReader(errorBody, ringBuffer) 11007 rootDecoder := xml.NewDecoder(body) 11008 t, err := smithyxml.FetchRootElement(rootDecoder) 11009 if err == io.EOF { 11010 return output 11011 } 11012 if err != nil { 11013 var snapshot bytes.Buffer 11014 io.Copy(&snapshot, ringBuffer) 11015 return &smithy.DeserializationError{ 11016 Err: fmt.Errorf("failed to decode response body, %w", err), 11017 Snapshot: snapshot.Bytes(), 11018 } 11019 } 11020 11021 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11022 t, err = decoder.GetElement("Error") 11023 if err != nil { 11024 var snapshot bytes.Buffer 11025 io.Copy(&snapshot, ringBuffer) 11026 return &smithy.DeserializationError{ 11027 Err: fmt.Errorf("failed to decode response body, %w", err), 11028 Snapshot: snapshot.Bytes(), 11029 } 11030 } 11031 11032 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11033 err = awsRestxml_deserializeDocumentInvalidKMSArn(&output, decoder) 11034 if err != nil { 11035 var snapshot bytes.Buffer 11036 io.Copy(&snapshot, ringBuffer) 11037 return &smithy.DeserializationError{ 11038 Err: fmt.Errorf("failed to decode response body, %w", err), 11039 Snapshot: snapshot.Bytes(), 11040 } 11041 } 11042 11043 return output 11044} 11045 11046func awsRestxml_deserializeErrorInvalidPaginationToken(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11047 output := &types.InvalidPaginationToken{} 11048 var buff [1024]byte 11049 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11050 body := io.TeeReader(errorBody, ringBuffer) 11051 rootDecoder := xml.NewDecoder(body) 11052 t, err := smithyxml.FetchRootElement(rootDecoder) 11053 if err == io.EOF { 11054 return output 11055 } 11056 if err != nil { 11057 var snapshot bytes.Buffer 11058 io.Copy(&snapshot, ringBuffer) 11059 return &smithy.DeserializationError{ 11060 Err: fmt.Errorf("failed to decode response body, %w", err), 11061 Snapshot: snapshot.Bytes(), 11062 } 11063 } 11064 11065 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11066 t, err = decoder.GetElement("Error") 11067 if err != nil { 11068 var snapshot bytes.Buffer 11069 io.Copy(&snapshot, ringBuffer) 11070 return &smithy.DeserializationError{ 11071 Err: fmt.Errorf("failed to decode response body, %w", err), 11072 Snapshot: snapshot.Bytes(), 11073 } 11074 } 11075 11076 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11077 err = awsRestxml_deserializeDocumentInvalidPaginationToken(&output, decoder) 11078 if err != nil { 11079 var snapshot bytes.Buffer 11080 io.Copy(&snapshot, ringBuffer) 11081 return &smithy.DeserializationError{ 11082 Err: fmt.Errorf("failed to decode response body, %w", err), 11083 Snapshot: snapshot.Bytes(), 11084 } 11085 } 11086 11087 return output 11088} 11089 11090func awsRestxml_deserializeErrorInvalidSigningStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11091 output := &types.InvalidSigningStatus{} 11092 var buff [1024]byte 11093 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11094 body := io.TeeReader(errorBody, ringBuffer) 11095 rootDecoder := xml.NewDecoder(body) 11096 t, err := smithyxml.FetchRootElement(rootDecoder) 11097 if err == io.EOF { 11098 return output 11099 } 11100 if err != nil { 11101 var snapshot bytes.Buffer 11102 io.Copy(&snapshot, ringBuffer) 11103 return &smithy.DeserializationError{ 11104 Err: fmt.Errorf("failed to decode response body, %w", err), 11105 Snapshot: snapshot.Bytes(), 11106 } 11107 } 11108 11109 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11110 t, err = decoder.GetElement("Error") 11111 if err != nil { 11112 var snapshot bytes.Buffer 11113 io.Copy(&snapshot, ringBuffer) 11114 return &smithy.DeserializationError{ 11115 Err: fmt.Errorf("failed to decode response body, %w", err), 11116 Snapshot: snapshot.Bytes(), 11117 } 11118 } 11119 11120 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11121 err = awsRestxml_deserializeDocumentInvalidSigningStatus(&output, decoder) 11122 if err != nil { 11123 var snapshot bytes.Buffer 11124 io.Copy(&snapshot, ringBuffer) 11125 return &smithy.DeserializationError{ 11126 Err: fmt.Errorf("failed to decode response body, %w", err), 11127 Snapshot: snapshot.Bytes(), 11128 } 11129 } 11130 11131 return output 11132} 11133 11134func awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11135 output := &types.InvalidTrafficPolicyDocument{} 11136 var buff [1024]byte 11137 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11138 body := io.TeeReader(errorBody, ringBuffer) 11139 rootDecoder := xml.NewDecoder(body) 11140 t, err := smithyxml.FetchRootElement(rootDecoder) 11141 if err == io.EOF { 11142 return output 11143 } 11144 if err != nil { 11145 var snapshot bytes.Buffer 11146 io.Copy(&snapshot, ringBuffer) 11147 return &smithy.DeserializationError{ 11148 Err: fmt.Errorf("failed to decode response body, %w", err), 11149 Snapshot: snapshot.Bytes(), 11150 } 11151 } 11152 11153 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11154 t, err = decoder.GetElement("Error") 11155 if err != nil { 11156 var snapshot bytes.Buffer 11157 io.Copy(&snapshot, ringBuffer) 11158 return &smithy.DeserializationError{ 11159 Err: fmt.Errorf("failed to decode response body, %w", err), 11160 Snapshot: snapshot.Bytes(), 11161 } 11162 } 11163 11164 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11165 err = awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(&output, decoder) 11166 if err != nil { 11167 var snapshot bytes.Buffer 11168 io.Copy(&snapshot, ringBuffer) 11169 return &smithy.DeserializationError{ 11170 Err: fmt.Errorf("failed to decode response body, %w", err), 11171 Snapshot: snapshot.Bytes(), 11172 } 11173 } 11174 11175 return output 11176} 11177 11178func awsRestxml_deserializeErrorInvalidVPCId(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11179 output := &types.InvalidVPCId{} 11180 var buff [1024]byte 11181 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11182 body := io.TeeReader(errorBody, ringBuffer) 11183 rootDecoder := xml.NewDecoder(body) 11184 t, err := smithyxml.FetchRootElement(rootDecoder) 11185 if err == io.EOF { 11186 return output 11187 } 11188 if err != nil { 11189 var snapshot bytes.Buffer 11190 io.Copy(&snapshot, ringBuffer) 11191 return &smithy.DeserializationError{ 11192 Err: fmt.Errorf("failed to decode response body, %w", err), 11193 Snapshot: snapshot.Bytes(), 11194 } 11195 } 11196 11197 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11198 t, err = decoder.GetElement("Error") 11199 if err != nil { 11200 var snapshot bytes.Buffer 11201 io.Copy(&snapshot, ringBuffer) 11202 return &smithy.DeserializationError{ 11203 Err: fmt.Errorf("failed to decode response body, %w", err), 11204 Snapshot: snapshot.Bytes(), 11205 } 11206 } 11207 11208 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11209 err = awsRestxml_deserializeDocumentInvalidVPCId(&output, decoder) 11210 if err != nil { 11211 var snapshot bytes.Buffer 11212 io.Copy(&snapshot, ringBuffer) 11213 return &smithy.DeserializationError{ 11214 Err: fmt.Errorf("failed to decode response body, %w", err), 11215 Snapshot: snapshot.Bytes(), 11216 } 11217 } 11218 11219 return output 11220} 11221 11222func awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11223 output := &types.KeySigningKeyAlreadyExists{} 11224 var buff [1024]byte 11225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11226 body := io.TeeReader(errorBody, ringBuffer) 11227 rootDecoder := xml.NewDecoder(body) 11228 t, err := smithyxml.FetchRootElement(rootDecoder) 11229 if err == io.EOF { 11230 return output 11231 } 11232 if err != nil { 11233 var snapshot bytes.Buffer 11234 io.Copy(&snapshot, ringBuffer) 11235 return &smithy.DeserializationError{ 11236 Err: fmt.Errorf("failed to decode response body, %w", err), 11237 Snapshot: snapshot.Bytes(), 11238 } 11239 } 11240 11241 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11242 t, err = decoder.GetElement("Error") 11243 if err != nil { 11244 var snapshot bytes.Buffer 11245 io.Copy(&snapshot, ringBuffer) 11246 return &smithy.DeserializationError{ 11247 Err: fmt.Errorf("failed to decode response body, %w", err), 11248 Snapshot: snapshot.Bytes(), 11249 } 11250 } 11251 11252 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11253 err = awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(&output, decoder) 11254 if err != nil { 11255 var snapshot bytes.Buffer 11256 io.Copy(&snapshot, ringBuffer) 11257 return &smithy.DeserializationError{ 11258 Err: fmt.Errorf("failed to decode response body, %w", err), 11259 Snapshot: snapshot.Bytes(), 11260 } 11261 } 11262 11263 return output 11264} 11265 11266func awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11267 output := &types.KeySigningKeyInParentDSRecord{} 11268 var buff [1024]byte 11269 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11270 body := io.TeeReader(errorBody, ringBuffer) 11271 rootDecoder := xml.NewDecoder(body) 11272 t, err := smithyxml.FetchRootElement(rootDecoder) 11273 if err == io.EOF { 11274 return output 11275 } 11276 if err != nil { 11277 var snapshot bytes.Buffer 11278 io.Copy(&snapshot, ringBuffer) 11279 return &smithy.DeserializationError{ 11280 Err: fmt.Errorf("failed to decode response body, %w", err), 11281 Snapshot: snapshot.Bytes(), 11282 } 11283 } 11284 11285 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11286 t, err = decoder.GetElement("Error") 11287 if err != nil { 11288 var snapshot bytes.Buffer 11289 io.Copy(&snapshot, ringBuffer) 11290 return &smithy.DeserializationError{ 11291 Err: fmt.Errorf("failed to decode response body, %w", err), 11292 Snapshot: snapshot.Bytes(), 11293 } 11294 } 11295 11296 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11297 err = awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(&output, decoder) 11298 if err != nil { 11299 var snapshot bytes.Buffer 11300 io.Copy(&snapshot, ringBuffer) 11301 return &smithy.DeserializationError{ 11302 Err: fmt.Errorf("failed to decode response body, %w", err), 11303 Snapshot: snapshot.Bytes(), 11304 } 11305 } 11306 11307 return output 11308} 11309 11310func awsRestxml_deserializeErrorKeySigningKeyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11311 output := &types.KeySigningKeyInUse{} 11312 var buff [1024]byte 11313 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11314 body := io.TeeReader(errorBody, ringBuffer) 11315 rootDecoder := xml.NewDecoder(body) 11316 t, err := smithyxml.FetchRootElement(rootDecoder) 11317 if err == io.EOF { 11318 return output 11319 } 11320 if err != nil { 11321 var snapshot bytes.Buffer 11322 io.Copy(&snapshot, ringBuffer) 11323 return &smithy.DeserializationError{ 11324 Err: fmt.Errorf("failed to decode response body, %w", err), 11325 Snapshot: snapshot.Bytes(), 11326 } 11327 } 11328 11329 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11330 t, err = decoder.GetElement("Error") 11331 if err != nil { 11332 var snapshot bytes.Buffer 11333 io.Copy(&snapshot, ringBuffer) 11334 return &smithy.DeserializationError{ 11335 Err: fmt.Errorf("failed to decode response body, %w", err), 11336 Snapshot: snapshot.Bytes(), 11337 } 11338 } 11339 11340 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11341 err = awsRestxml_deserializeDocumentKeySigningKeyInUse(&output, decoder) 11342 if err != nil { 11343 var snapshot bytes.Buffer 11344 io.Copy(&snapshot, ringBuffer) 11345 return &smithy.DeserializationError{ 11346 Err: fmt.Errorf("failed to decode response body, %w", err), 11347 Snapshot: snapshot.Bytes(), 11348 } 11349 } 11350 11351 return output 11352} 11353 11354func awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11355 output := &types.KeySigningKeyWithActiveStatusNotFound{} 11356 var buff [1024]byte 11357 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11358 body := io.TeeReader(errorBody, ringBuffer) 11359 rootDecoder := xml.NewDecoder(body) 11360 t, err := smithyxml.FetchRootElement(rootDecoder) 11361 if err == io.EOF { 11362 return output 11363 } 11364 if err != nil { 11365 var snapshot bytes.Buffer 11366 io.Copy(&snapshot, ringBuffer) 11367 return &smithy.DeserializationError{ 11368 Err: fmt.Errorf("failed to decode response body, %w", err), 11369 Snapshot: snapshot.Bytes(), 11370 } 11371 } 11372 11373 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11374 t, err = decoder.GetElement("Error") 11375 if err != nil { 11376 var snapshot bytes.Buffer 11377 io.Copy(&snapshot, ringBuffer) 11378 return &smithy.DeserializationError{ 11379 Err: fmt.Errorf("failed to decode response body, %w", err), 11380 Snapshot: snapshot.Bytes(), 11381 } 11382 } 11383 11384 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11385 err = awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(&output, decoder) 11386 if err != nil { 11387 var snapshot bytes.Buffer 11388 io.Copy(&snapshot, ringBuffer) 11389 return &smithy.DeserializationError{ 11390 Err: fmt.Errorf("failed to decode response body, %w", err), 11391 Snapshot: snapshot.Bytes(), 11392 } 11393 } 11394 11395 return output 11396} 11397 11398func awsRestxml_deserializeErrorLastVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11399 output := &types.LastVPCAssociation{} 11400 var buff [1024]byte 11401 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11402 body := io.TeeReader(errorBody, ringBuffer) 11403 rootDecoder := xml.NewDecoder(body) 11404 t, err := smithyxml.FetchRootElement(rootDecoder) 11405 if err == io.EOF { 11406 return output 11407 } 11408 if err != nil { 11409 var snapshot bytes.Buffer 11410 io.Copy(&snapshot, ringBuffer) 11411 return &smithy.DeserializationError{ 11412 Err: fmt.Errorf("failed to decode response body, %w", err), 11413 Snapshot: snapshot.Bytes(), 11414 } 11415 } 11416 11417 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11418 t, err = decoder.GetElement("Error") 11419 if err != nil { 11420 var snapshot bytes.Buffer 11421 io.Copy(&snapshot, ringBuffer) 11422 return &smithy.DeserializationError{ 11423 Err: fmt.Errorf("failed to decode response body, %w", err), 11424 Snapshot: snapshot.Bytes(), 11425 } 11426 } 11427 11428 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11429 err = awsRestxml_deserializeDocumentLastVPCAssociation(&output, decoder) 11430 if err != nil { 11431 var snapshot bytes.Buffer 11432 io.Copy(&snapshot, ringBuffer) 11433 return &smithy.DeserializationError{ 11434 Err: fmt.Errorf("failed to decode response body, %w", err), 11435 Snapshot: snapshot.Bytes(), 11436 } 11437 } 11438 11439 return output 11440} 11441 11442func awsRestxml_deserializeErrorLimitsExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11443 output := &types.LimitsExceeded{} 11444 var buff [1024]byte 11445 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11446 body := io.TeeReader(errorBody, ringBuffer) 11447 rootDecoder := xml.NewDecoder(body) 11448 t, err := smithyxml.FetchRootElement(rootDecoder) 11449 if err == io.EOF { 11450 return output 11451 } 11452 if err != nil { 11453 var snapshot bytes.Buffer 11454 io.Copy(&snapshot, ringBuffer) 11455 return &smithy.DeserializationError{ 11456 Err: fmt.Errorf("failed to decode response body, %w", err), 11457 Snapshot: snapshot.Bytes(), 11458 } 11459 } 11460 11461 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11462 t, err = decoder.GetElement("Error") 11463 if err != nil { 11464 var snapshot bytes.Buffer 11465 io.Copy(&snapshot, ringBuffer) 11466 return &smithy.DeserializationError{ 11467 Err: fmt.Errorf("failed to decode response body, %w", err), 11468 Snapshot: snapshot.Bytes(), 11469 } 11470 } 11471 11472 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11473 err = awsRestxml_deserializeDocumentLimitsExceeded(&output, decoder) 11474 if err != nil { 11475 var snapshot bytes.Buffer 11476 io.Copy(&snapshot, ringBuffer) 11477 return &smithy.DeserializationError{ 11478 Err: fmt.Errorf("failed to decode response body, %w", err), 11479 Snapshot: snapshot.Bytes(), 11480 } 11481 } 11482 11483 return output 11484} 11485 11486func awsRestxml_deserializeErrorNoSuchChange(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11487 output := &types.NoSuchChange{} 11488 var buff [1024]byte 11489 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11490 body := io.TeeReader(errorBody, ringBuffer) 11491 rootDecoder := xml.NewDecoder(body) 11492 t, err := smithyxml.FetchRootElement(rootDecoder) 11493 if err == io.EOF { 11494 return output 11495 } 11496 if err != nil { 11497 var snapshot bytes.Buffer 11498 io.Copy(&snapshot, ringBuffer) 11499 return &smithy.DeserializationError{ 11500 Err: fmt.Errorf("failed to decode response body, %w", err), 11501 Snapshot: snapshot.Bytes(), 11502 } 11503 } 11504 11505 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11506 t, err = decoder.GetElement("Error") 11507 if err != nil { 11508 var snapshot bytes.Buffer 11509 io.Copy(&snapshot, ringBuffer) 11510 return &smithy.DeserializationError{ 11511 Err: fmt.Errorf("failed to decode response body, %w", err), 11512 Snapshot: snapshot.Bytes(), 11513 } 11514 } 11515 11516 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11517 err = awsRestxml_deserializeDocumentNoSuchChange(&output, decoder) 11518 if err != nil { 11519 var snapshot bytes.Buffer 11520 io.Copy(&snapshot, ringBuffer) 11521 return &smithy.DeserializationError{ 11522 Err: fmt.Errorf("failed to decode response body, %w", err), 11523 Snapshot: snapshot.Bytes(), 11524 } 11525 } 11526 11527 return output 11528} 11529 11530func awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11531 output := &types.NoSuchCloudWatchLogsLogGroup{} 11532 var buff [1024]byte 11533 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11534 body := io.TeeReader(errorBody, ringBuffer) 11535 rootDecoder := xml.NewDecoder(body) 11536 t, err := smithyxml.FetchRootElement(rootDecoder) 11537 if err == io.EOF { 11538 return output 11539 } 11540 if err != nil { 11541 var snapshot bytes.Buffer 11542 io.Copy(&snapshot, ringBuffer) 11543 return &smithy.DeserializationError{ 11544 Err: fmt.Errorf("failed to decode response body, %w", err), 11545 Snapshot: snapshot.Bytes(), 11546 } 11547 } 11548 11549 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11550 t, err = decoder.GetElement("Error") 11551 if err != nil { 11552 var snapshot bytes.Buffer 11553 io.Copy(&snapshot, ringBuffer) 11554 return &smithy.DeserializationError{ 11555 Err: fmt.Errorf("failed to decode response body, %w", err), 11556 Snapshot: snapshot.Bytes(), 11557 } 11558 } 11559 11560 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11561 err = awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(&output, decoder) 11562 if err != nil { 11563 var snapshot bytes.Buffer 11564 io.Copy(&snapshot, ringBuffer) 11565 return &smithy.DeserializationError{ 11566 Err: fmt.Errorf("failed to decode response body, %w", err), 11567 Snapshot: snapshot.Bytes(), 11568 } 11569 } 11570 11571 return output 11572} 11573 11574func awsRestxml_deserializeErrorNoSuchDelegationSet(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11575 output := &types.NoSuchDelegationSet{} 11576 var buff [1024]byte 11577 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11578 body := io.TeeReader(errorBody, ringBuffer) 11579 rootDecoder := xml.NewDecoder(body) 11580 t, err := smithyxml.FetchRootElement(rootDecoder) 11581 if err == io.EOF { 11582 return output 11583 } 11584 if err != nil { 11585 var snapshot bytes.Buffer 11586 io.Copy(&snapshot, ringBuffer) 11587 return &smithy.DeserializationError{ 11588 Err: fmt.Errorf("failed to decode response body, %w", err), 11589 Snapshot: snapshot.Bytes(), 11590 } 11591 } 11592 11593 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11594 t, err = decoder.GetElement("Error") 11595 if err != nil { 11596 var snapshot bytes.Buffer 11597 io.Copy(&snapshot, ringBuffer) 11598 return &smithy.DeserializationError{ 11599 Err: fmt.Errorf("failed to decode response body, %w", err), 11600 Snapshot: snapshot.Bytes(), 11601 } 11602 } 11603 11604 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11605 err = awsRestxml_deserializeDocumentNoSuchDelegationSet(&output, decoder) 11606 if err != nil { 11607 var snapshot bytes.Buffer 11608 io.Copy(&snapshot, ringBuffer) 11609 return &smithy.DeserializationError{ 11610 Err: fmt.Errorf("failed to decode response body, %w", err), 11611 Snapshot: snapshot.Bytes(), 11612 } 11613 } 11614 11615 return output 11616} 11617 11618func awsRestxml_deserializeErrorNoSuchGeoLocation(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11619 output := &types.NoSuchGeoLocation{} 11620 var buff [1024]byte 11621 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11622 body := io.TeeReader(errorBody, ringBuffer) 11623 rootDecoder := xml.NewDecoder(body) 11624 t, err := smithyxml.FetchRootElement(rootDecoder) 11625 if err == io.EOF { 11626 return output 11627 } 11628 if err != nil { 11629 var snapshot bytes.Buffer 11630 io.Copy(&snapshot, ringBuffer) 11631 return &smithy.DeserializationError{ 11632 Err: fmt.Errorf("failed to decode response body, %w", err), 11633 Snapshot: snapshot.Bytes(), 11634 } 11635 } 11636 11637 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11638 t, err = decoder.GetElement("Error") 11639 if err != nil { 11640 var snapshot bytes.Buffer 11641 io.Copy(&snapshot, ringBuffer) 11642 return &smithy.DeserializationError{ 11643 Err: fmt.Errorf("failed to decode response body, %w", err), 11644 Snapshot: snapshot.Bytes(), 11645 } 11646 } 11647 11648 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11649 err = awsRestxml_deserializeDocumentNoSuchGeoLocation(&output, decoder) 11650 if err != nil { 11651 var snapshot bytes.Buffer 11652 io.Copy(&snapshot, ringBuffer) 11653 return &smithy.DeserializationError{ 11654 Err: fmt.Errorf("failed to decode response body, %w", err), 11655 Snapshot: snapshot.Bytes(), 11656 } 11657 } 11658 11659 return output 11660} 11661 11662func awsRestxml_deserializeErrorNoSuchHealthCheck(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11663 output := &types.NoSuchHealthCheck{} 11664 var buff [1024]byte 11665 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11666 body := io.TeeReader(errorBody, ringBuffer) 11667 rootDecoder := xml.NewDecoder(body) 11668 t, err := smithyxml.FetchRootElement(rootDecoder) 11669 if err == io.EOF { 11670 return output 11671 } 11672 if err != nil { 11673 var snapshot bytes.Buffer 11674 io.Copy(&snapshot, ringBuffer) 11675 return &smithy.DeserializationError{ 11676 Err: fmt.Errorf("failed to decode response body, %w", err), 11677 Snapshot: snapshot.Bytes(), 11678 } 11679 } 11680 11681 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11682 t, err = decoder.GetElement("Error") 11683 if err != nil { 11684 var snapshot bytes.Buffer 11685 io.Copy(&snapshot, ringBuffer) 11686 return &smithy.DeserializationError{ 11687 Err: fmt.Errorf("failed to decode response body, %w", err), 11688 Snapshot: snapshot.Bytes(), 11689 } 11690 } 11691 11692 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11693 err = awsRestxml_deserializeDocumentNoSuchHealthCheck(&output, decoder) 11694 if err != nil { 11695 var snapshot bytes.Buffer 11696 io.Copy(&snapshot, ringBuffer) 11697 return &smithy.DeserializationError{ 11698 Err: fmt.Errorf("failed to decode response body, %w", err), 11699 Snapshot: snapshot.Bytes(), 11700 } 11701 } 11702 11703 return output 11704} 11705 11706func awsRestxml_deserializeErrorNoSuchHostedZone(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11707 output := &types.NoSuchHostedZone{} 11708 var buff [1024]byte 11709 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11710 body := io.TeeReader(errorBody, ringBuffer) 11711 rootDecoder := xml.NewDecoder(body) 11712 t, err := smithyxml.FetchRootElement(rootDecoder) 11713 if err == io.EOF { 11714 return output 11715 } 11716 if err != nil { 11717 var snapshot bytes.Buffer 11718 io.Copy(&snapshot, ringBuffer) 11719 return &smithy.DeserializationError{ 11720 Err: fmt.Errorf("failed to decode response body, %w", err), 11721 Snapshot: snapshot.Bytes(), 11722 } 11723 } 11724 11725 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11726 t, err = decoder.GetElement("Error") 11727 if err != nil { 11728 var snapshot bytes.Buffer 11729 io.Copy(&snapshot, ringBuffer) 11730 return &smithy.DeserializationError{ 11731 Err: fmt.Errorf("failed to decode response body, %w", err), 11732 Snapshot: snapshot.Bytes(), 11733 } 11734 } 11735 11736 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11737 err = awsRestxml_deserializeDocumentNoSuchHostedZone(&output, decoder) 11738 if err != nil { 11739 var snapshot bytes.Buffer 11740 io.Copy(&snapshot, ringBuffer) 11741 return &smithy.DeserializationError{ 11742 Err: fmt.Errorf("failed to decode response body, %w", err), 11743 Snapshot: snapshot.Bytes(), 11744 } 11745 } 11746 11747 return output 11748} 11749 11750func awsRestxml_deserializeErrorNoSuchKeySigningKey(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11751 output := &types.NoSuchKeySigningKey{} 11752 var buff [1024]byte 11753 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11754 body := io.TeeReader(errorBody, ringBuffer) 11755 rootDecoder := xml.NewDecoder(body) 11756 t, err := smithyxml.FetchRootElement(rootDecoder) 11757 if err == io.EOF { 11758 return output 11759 } 11760 if err != nil { 11761 var snapshot bytes.Buffer 11762 io.Copy(&snapshot, ringBuffer) 11763 return &smithy.DeserializationError{ 11764 Err: fmt.Errorf("failed to decode response body, %w", err), 11765 Snapshot: snapshot.Bytes(), 11766 } 11767 } 11768 11769 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11770 t, err = decoder.GetElement("Error") 11771 if err != nil { 11772 var snapshot bytes.Buffer 11773 io.Copy(&snapshot, ringBuffer) 11774 return &smithy.DeserializationError{ 11775 Err: fmt.Errorf("failed to decode response body, %w", err), 11776 Snapshot: snapshot.Bytes(), 11777 } 11778 } 11779 11780 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11781 err = awsRestxml_deserializeDocumentNoSuchKeySigningKey(&output, decoder) 11782 if err != nil { 11783 var snapshot bytes.Buffer 11784 io.Copy(&snapshot, ringBuffer) 11785 return &smithy.DeserializationError{ 11786 Err: fmt.Errorf("failed to decode response body, %w", err), 11787 Snapshot: snapshot.Bytes(), 11788 } 11789 } 11790 11791 return output 11792} 11793 11794func awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11795 output := &types.NoSuchQueryLoggingConfig{} 11796 var buff [1024]byte 11797 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11798 body := io.TeeReader(errorBody, ringBuffer) 11799 rootDecoder := xml.NewDecoder(body) 11800 t, err := smithyxml.FetchRootElement(rootDecoder) 11801 if err == io.EOF { 11802 return output 11803 } 11804 if err != nil { 11805 var snapshot bytes.Buffer 11806 io.Copy(&snapshot, ringBuffer) 11807 return &smithy.DeserializationError{ 11808 Err: fmt.Errorf("failed to decode response body, %w", err), 11809 Snapshot: snapshot.Bytes(), 11810 } 11811 } 11812 11813 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11814 t, err = decoder.GetElement("Error") 11815 if err != nil { 11816 var snapshot bytes.Buffer 11817 io.Copy(&snapshot, ringBuffer) 11818 return &smithy.DeserializationError{ 11819 Err: fmt.Errorf("failed to decode response body, %w", err), 11820 Snapshot: snapshot.Bytes(), 11821 } 11822 } 11823 11824 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11825 err = awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(&output, decoder) 11826 if err != nil { 11827 var snapshot bytes.Buffer 11828 io.Copy(&snapshot, ringBuffer) 11829 return &smithy.DeserializationError{ 11830 Err: fmt.Errorf("failed to decode response body, %w", err), 11831 Snapshot: snapshot.Bytes(), 11832 } 11833 } 11834 11835 return output 11836} 11837 11838func awsRestxml_deserializeErrorNoSuchTrafficPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11839 output := &types.NoSuchTrafficPolicy{} 11840 var buff [1024]byte 11841 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11842 body := io.TeeReader(errorBody, ringBuffer) 11843 rootDecoder := xml.NewDecoder(body) 11844 t, err := smithyxml.FetchRootElement(rootDecoder) 11845 if err == io.EOF { 11846 return output 11847 } 11848 if err != nil { 11849 var snapshot bytes.Buffer 11850 io.Copy(&snapshot, ringBuffer) 11851 return &smithy.DeserializationError{ 11852 Err: fmt.Errorf("failed to decode response body, %w", err), 11853 Snapshot: snapshot.Bytes(), 11854 } 11855 } 11856 11857 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11858 t, err = decoder.GetElement("Error") 11859 if err != nil { 11860 var snapshot bytes.Buffer 11861 io.Copy(&snapshot, ringBuffer) 11862 return &smithy.DeserializationError{ 11863 Err: fmt.Errorf("failed to decode response body, %w", err), 11864 Snapshot: snapshot.Bytes(), 11865 } 11866 } 11867 11868 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11869 err = awsRestxml_deserializeDocumentNoSuchTrafficPolicy(&output, decoder) 11870 if err != nil { 11871 var snapshot bytes.Buffer 11872 io.Copy(&snapshot, ringBuffer) 11873 return &smithy.DeserializationError{ 11874 Err: fmt.Errorf("failed to decode response body, %w", err), 11875 Snapshot: snapshot.Bytes(), 11876 } 11877 } 11878 11879 return output 11880} 11881 11882func awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11883 output := &types.NoSuchTrafficPolicyInstance{} 11884 var buff [1024]byte 11885 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11886 body := io.TeeReader(errorBody, ringBuffer) 11887 rootDecoder := xml.NewDecoder(body) 11888 t, err := smithyxml.FetchRootElement(rootDecoder) 11889 if err == io.EOF { 11890 return output 11891 } 11892 if err != nil { 11893 var snapshot bytes.Buffer 11894 io.Copy(&snapshot, ringBuffer) 11895 return &smithy.DeserializationError{ 11896 Err: fmt.Errorf("failed to decode response body, %w", err), 11897 Snapshot: snapshot.Bytes(), 11898 } 11899 } 11900 11901 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11902 t, err = decoder.GetElement("Error") 11903 if err != nil { 11904 var snapshot bytes.Buffer 11905 io.Copy(&snapshot, ringBuffer) 11906 return &smithy.DeserializationError{ 11907 Err: fmt.Errorf("failed to decode response body, %w", err), 11908 Snapshot: snapshot.Bytes(), 11909 } 11910 } 11911 11912 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11913 err = awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(&output, decoder) 11914 if err != nil { 11915 var snapshot bytes.Buffer 11916 io.Copy(&snapshot, ringBuffer) 11917 return &smithy.DeserializationError{ 11918 Err: fmt.Errorf("failed to decode response body, %w", err), 11919 Snapshot: snapshot.Bytes(), 11920 } 11921 } 11922 11923 return output 11924} 11925 11926func awsRestxml_deserializeErrorNotAuthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11927 output := &types.NotAuthorizedException{} 11928 var buff [1024]byte 11929 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11930 body := io.TeeReader(errorBody, ringBuffer) 11931 rootDecoder := xml.NewDecoder(body) 11932 t, err := smithyxml.FetchRootElement(rootDecoder) 11933 if err == io.EOF { 11934 return output 11935 } 11936 if err != nil { 11937 var snapshot bytes.Buffer 11938 io.Copy(&snapshot, ringBuffer) 11939 return &smithy.DeserializationError{ 11940 Err: fmt.Errorf("failed to decode response body, %w", err), 11941 Snapshot: snapshot.Bytes(), 11942 } 11943 } 11944 11945 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11946 t, err = decoder.GetElement("Error") 11947 if err != nil { 11948 var snapshot bytes.Buffer 11949 io.Copy(&snapshot, ringBuffer) 11950 return &smithy.DeserializationError{ 11951 Err: fmt.Errorf("failed to decode response body, %w", err), 11952 Snapshot: snapshot.Bytes(), 11953 } 11954 } 11955 11956 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11957 err = awsRestxml_deserializeDocumentNotAuthorizedException(&output, decoder) 11958 if err != nil { 11959 var snapshot bytes.Buffer 11960 io.Copy(&snapshot, ringBuffer) 11961 return &smithy.DeserializationError{ 11962 Err: fmt.Errorf("failed to decode response body, %w", err), 11963 Snapshot: snapshot.Bytes(), 11964 } 11965 } 11966 11967 return output 11968} 11969 11970func awsRestxml_deserializeErrorPriorRequestNotComplete(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11971 output := &types.PriorRequestNotComplete{} 11972 var buff [1024]byte 11973 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11974 body := io.TeeReader(errorBody, ringBuffer) 11975 rootDecoder := xml.NewDecoder(body) 11976 t, err := smithyxml.FetchRootElement(rootDecoder) 11977 if err == io.EOF { 11978 return output 11979 } 11980 if err != nil { 11981 var snapshot bytes.Buffer 11982 io.Copy(&snapshot, ringBuffer) 11983 return &smithy.DeserializationError{ 11984 Err: fmt.Errorf("failed to decode response body, %w", err), 11985 Snapshot: snapshot.Bytes(), 11986 } 11987 } 11988 11989 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11990 t, err = decoder.GetElement("Error") 11991 if err != nil { 11992 var snapshot bytes.Buffer 11993 io.Copy(&snapshot, ringBuffer) 11994 return &smithy.DeserializationError{ 11995 Err: fmt.Errorf("failed to decode response body, %w", err), 11996 Snapshot: snapshot.Bytes(), 11997 } 11998 } 11999 12000 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12001 err = awsRestxml_deserializeDocumentPriorRequestNotComplete(&output, decoder) 12002 if err != nil { 12003 var snapshot bytes.Buffer 12004 io.Copy(&snapshot, ringBuffer) 12005 return &smithy.DeserializationError{ 12006 Err: fmt.Errorf("failed to decode response body, %w", err), 12007 Snapshot: snapshot.Bytes(), 12008 } 12009 } 12010 12011 return output 12012} 12013 12014func awsRestxml_deserializeErrorPublicZoneVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12015 output := &types.PublicZoneVPCAssociation{} 12016 var buff [1024]byte 12017 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12018 body := io.TeeReader(errorBody, ringBuffer) 12019 rootDecoder := xml.NewDecoder(body) 12020 t, err := smithyxml.FetchRootElement(rootDecoder) 12021 if err == io.EOF { 12022 return output 12023 } 12024 if err != nil { 12025 var snapshot bytes.Buffer 12026 io.Copy(&snapshot, ringBuffer) 12027 return &smithy.DeserializationError{ 12028 Err: fmt.Errorf("failed to decode response body, %w", err), 12029 Snapshot: snapshot.Bytes(), 12030 } 12031 } 12032 12033 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12034 t, err = decoder.GetElement("Error") 12035 if err != nil { 12036 var snapshot bytes.Buffer 12037 io.Copy(&snapshot, ringBuffer) 12038 return &smithy.DeserializationError{ 12039 Err: fmt.Errorf("failed to decode response body, %w", err), 12040 Snapshot: snapshot.Bytes(), 12041 } 12042 } 12043 12044 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12045 err = awsRestxml_deserializeDocumentPublicZoneVPCAssociation(&output, decoder) 12046 if err != nil { 12047 var snapshot bytes.Buffer 12048 io.Copy(&snapshot, ringBuffer) 12049 return &smithy.DeserializationError{ 12050 Err: fmt.Errorf("failed to decode response body, %w", err), 12051 Snapshot: snapshot.Bytes(), 12052 } 12053 } 12054 12055 return output 12056} 12057 12058func awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12059 output := &types.QueryLoggingConfigAlreadyExists{} 12060 var buff [1024]byte 12061 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12062 body := io.TeeReader(errorBody, ringBuffer) 12063 rootDecoder := xml.NewDecoder(body) 12064 t, err := smithyxml.FetchRootElement(rootDecoder) 12065 if err == io.EOF { 12066 return output 12067 } 12068 if err != nil { 12069 var snapshot bytes.Buffer 12070 io.Copy(&snapshot, ringBuffer) 12071 return &smithy.DeserializationError{ 12072 Err: fmt.Errorf("failed to decode response body, %w", err), 12073 Snapshot: snapshot.Bytes(), 12074 } 12075 } 12076 12077 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12078 t, err = decoder.GetElement("Error") 12079 if err != nil { 12080 var snapshot bytes.Buffer 12081 io.Copy(&snapshot, ringBuffer) 12082 return &smithy.DeserializationError{ 12083 Err: fmt.Errorf("failed to decode response body, %w", err), 12084 Snapshot: snapshot.Bytes(), 12085 } 12086 } 12087 12088 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12089 err = awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(&output, decoder) 12090 if err != nil { 12091 var snapshot bytes.Buffer 12092 io.Copy(&snapshot, ringBuffer) 12093 return &smithy.DeserializationError{ 12094 Err: fmt.Errorf("failed to decode response body, %w", err), 12095 Snapshot: snapshot.Bytes(), 12096 } 12097 } 12098 12099 return output 12100} 12101 12102func awsRestxml_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12103 output := &types.ThrottlingException{} 12104 var buff [1024]byte 12105 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12106 body := io.TeeReader(errorBody, ringBuffer) 12107 rootDecoder := xml.NewDecoder(body) 12108 t, err := smithyxml.FetchRootElement(rootDecoder) 12109 if err == io.EOF { 12110 return output 12111 } 12112 if err != nil { 12113 var snapshot bytes.Buffer 12114 io.Copy(&snapshot, ringBuffer) 12115 return &smithy.DeserializationError{ 12116 Err: fmt.Errorf("failed to decode response body, %w", err), 12117 Snapshot: snapshot.Bytes(), 12118 } 12119 } 12120 12121 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12122 t, err = decoder.GetElement("Error") 12123 if err != nil { 12124 var snapshot bytes.Buffer 12125 io.Copy(&snapshot, ringBuffer) 12126 return &smithy.DeserializationError{ 12127 Err: fmt.Errorf("failed to decode response body, %w", err), 12128 Snapshot: snapshot.Bytes(), 12129 } 12130 } 12131 12132 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12133 err = awsRestxml_deserializeDocumentThrottlingException(&output, decoder) 12134 if err != nil { 12135 var snapshot bytes.Buffer 12136 io.Copy(&snapshot, ringBuffer) 12137 return &smithy.DeserializationError{ 12138 Err: fmt.Errorf("failed to decode response body, %w", err), 12139 Snapshot: snapshot.Bytes(), 12140 } 12141 } 12142 12143 return output 12144} 12145 12146func awsRestxml_deserializeErrorTooManyHealthChecks(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12147 output := &types.TooManyHealthChecks{} 12148 var buff [1024]byte 12149 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12150 body := io.TeeReader(errorBody, ringBuffer) 12151 rootDecoder := xml.NewDecoder(body) 12152 t, err := smithyxml.FetchRootElement(rootDecoder) 12153 if err == io.EOF { 12154 return output 12155 } 12156 if err != nil { 12157 var snapshot bytes.Buffer 12158 io.Copy(&snapshot, ringBuffer) 12159 return &smithy.DeserializationError{ 12160 Err: fmt.Errorf("failed to decode response body, %w", err), 12161 Snapshot: snapshot.Bytes(), 12162 } 12163 } 12164 12165 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12166 t, err = decoder.GetElement("Error") 12167 if err != nil { 12168 var snapshot bytes.Buffer 12169 io.Copy(&snapshot, ringBuffer) 12170 return &smithy.DeserializationError{ 12171 Err: fmt.Errorf("failed to decode response body, %w", err), 12172 Snapshot: snapshot.Bytes(), 12173 } 12174 } 12175 12176 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12177 err = awsRestxml_deserializeDocumentTooManyHealthChecks(&output, decoder) 12178 if err != nil { 12179 var snapshot bytes.Buffer 12180 io.Copy(&snapshot, ringBuffer) 12181 return &smithy.DeserializationError{ 12182 Err: fmt.Errorf("failed to decode response body, %w", err), 12183 Snapshot: snapshot.Bytes(), 12184 } 12185 } 12186 12187 return output 12188} 12189 12190func awsRestxml_deserializeErrorTooManyHostedZones(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12191 output := &types.TooManyHostedZones{} 12192 var buff [1024]byte 12193 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12194 body := io.TeeReader(errorBody, ringBuffer) 12195 rootDecoder := xml.NewDecoder(body) 12196 t, err := smithyxml.FetchRootElement(rootDecoder) 12197 if err == io.EOF { 12198 return output 12199 } 12200 if err != nil { 12201 var snapshot bytes.Buffer 12202 io.Copy(&snapshot, ringBuffer) 12203 return &smithy.DeserializationError{ 12204 Err: fmt.Errorf("failed to decode response body, %w", err), 12205 Snapshot: snapshot.Bytes(), 12206 } 12207 } 12208 12209 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12210 t, err = decoder.GetElement("Error") 12211 if err != nil { 12212 var snapshot bytes.Buffer 12213 io.Copy(&snapshot, ringBuffer) 12214 return &smithy.DeserializationError{ 12215 Err: fmt.Errorf("failed to decode response body, %w", err), 12216 Snapshot: snapshot.Bytes(), 12217 } 12218 } 12219 12220 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12221 err = awsRestxml_deserializeDocumentTooManyHostedZones(&output, decoder) 12222 if err != nil { 12223 var snapshot bytes.Buffer 12224 io.Copy(&snapshot, ringBuffer) 12225 return &smithy.DeserializationError{ 12226 Err: fmt.Errorf("failed to decode response body, %w", err), 12227 Snapshot: snapshot.Bytes(), 12228 } 12229 } 12230 12231 return output 12232} 12233 12234func awsRestxml_deserializeErrorTooManyKeySigningKeys(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12235 output := &types.TooManyKeySigningKeys{} 12236 var buff [1024]byte 12237 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12238 body := io.TeeReader(errorBody, ringBuffer) 12239 rootDecoder := xml.NewDecoder(body) 12240 t, err := smithyxml.FetchRootElement(rootDecoder) 12241 if err == io.EOF { 12242 return output 12243 } 12244 if err != nil { 12245 var snapshot bytes.Buffer 12246 io.Copy(&snapshot, ringBuffer) 12247 return &smithy.DeserializationError{ 12248 Err: fmt.Errorf("failed to decode response body, %w", err), 12249 Snapshot: snapshot.Bytes(), 12250 } 12251 } 12252 12253 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12254 t, err = decoder.GetElement("Error") 12255 if err != nil { 12256 var snapshot bytes.Buffer 12257 io.Copy(&snapshot, ringBuffer) 12258 return &smithy.DeserializationError{ 12259 Err: fmt.Errorf("failed to decode response body, %w", err), 12260 Snapshot: snapshot.Bytes(), 12261 } 12262 } 12263 12264 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12265 err = awsRestxml_deserializeDocumentTooManyKeySigningKeys(&output, decoder) 12266 if err != nil { 12267 var snapshot bytes.Buffer 12268 io.Copy(&snapshot, ringBuffer) 12269 return &smithy.DeserializationError{ 12270 Err: fmt.Errorf("failed to decode response body, %w", err), 12271 Snapshot: snapshot.Bytes(), 12272 } 12273 } 12274 12275 return output 12276} 12277 12278func awsRestxml_deserializeErrorTooManyTrafficPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12279 output := &types.TooManyTrafficPolicies{} 12280 var buff [1024]byte 12281 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12282 body := io.TeeReader(errorBody, ringBuffer) 12283 rootDecoder := xml.NewDecoder(body) 12284 t, err := smithyxml.FetchRootElement(rootDecoder) 12285 if err == io.EOF { 12286 return output 12287 } 12288 if err != nil { 12289 var snapshot bytes.Buffer 12290 io.Copy(&snapshot, ringBuffer) 12291 return &smithy.DeserializationError{ 12292 Err: fmt.Errorf("failed to decode response body, %w", err), 12293 Snapshot: snapshot.Bytes(), 12294 } 12295 } 12296 12297 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12298 t, err = decoder.GetElement("Error") 12299 if err != nil { 12300 var snapshot bytes.Buffer 12301 io.Copy(&snapshot, ringBuffer) 12302 return &smithy.DeserializationError{ 12303 Err: fmt.Errorf("failed to decode response body, %w", err), 12304 Snapshot: snapshot.Bytes(), 12305 } 12306 } 12307 12308 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12309 err = awsRestxml_deserializeDocumentTooManyTrafficPolicies(&output, decoder) 12310 if err != nil { 12311 var snapshot bytes.Buffer 12312 io.Copy(&snapshot, ringBuffer) 12313 return &smithy.DeserializationError{ 12314 Err: fmt.Errorf("failed to decode response body, %w", err), 12315 Snapshot: snapshot.Bytes(), 12316 } 12317 } 12318 12319 return output 12320} 12321 12322func awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12323 output := &types.TooManyTrafficPolicyInstances{} 12324 var buff [1024]byte 12325 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12326 body := io.TeeReader(errorBody, ringBuffer) 12327 rootDecoder := xml.NewDecoder(body) 12328 t, err := smithyxml.FetchRootElement(rootDecoder) 12329 if err == io.EOF { 12330 return output 12331 } 12332 if err != nil { 12333 var snapshot bytes.Buffer 12334 io.Copy(&snapshot, ringBuffer) 12335 return &smithy.DeserializationError{ 12336 Err: fmt.Errorf("failed to decode response body, %w", err), 12337 Snapshot: snapshot.Bytes(), 12338 } 12339 } 12340 12341 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12342 t, err = decoder.GetElement("Error") 12343 if err != nil { 12344 var snapshot bytes.Buffer 12345 io.Copy(&snapshot, ringBuffer) 12346 return &smithy.DeserializationError{ 12347 Err: fmt.Errorf("failed to decode response body, %w", err), 12348 Snapshot: snapshot.Bytes(), 12349 } 12350 } 12351 12352 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12353 err = awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(&output, decoder) 12354 if err != nil { 12355 var snapshot bytes.Buffer 12356 io.Copy(&snapshot, ringBuffer) 12357 return &smithy.DeserializationError{ 12358 Err: fmt.Errorf("failed to decode response body, %w", err), 12359 Snapshot: snapshot.Bytes(), 12360 } 12361 } 12362 12363 return output 12364} 12365 12366func awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12367 output := &types.TooManyTrafficPolicyVersionsForCurrentPolicy{} 12368 var buff [1024]byte 12369 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12370 body := io.TeeReader(errorBody, ringBuffer) 12371 rootDecoder := xml.NewDecoder(body) 12372 t, err := smithyxml.FetchRootElement(rootDecoder) 12373 if err == io.EOF { 12374 return output 12375 } 12376 if err != nil { 12377 var snapshot bytes.Buffer 12378 io.Copy(&snapshot, ringBuffer) 12379 return &smithy.DeserializationError{ 12380 Err: fmt.Errorf("failed to decode response body, %w", err), 12381 Snapshot: snapshot.Bytes(), 12382 } 12383 } 12384 12385 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12386 t, err = decoder.GetElement("Error") 12387 if err != nil { 12388 var snapshot bytes.Buffer 12389 io.Copy(&snapshot, ringBuffer) 12390 return &smithy.DeserializationError{ 12391 Err: fmt.Errorf("failed to decode response body, %w", err), 12392 Snapshot: snapshot.Bytes(), 12393 } 12394 } 12395 12396 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12397 err = awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(&output, decoder) 12398 if err != nil { 12399 var snapshot bytes.Buffer 12400 io.Copy(&snapshot, ringBuffer) 12401 return &smithy.DeserializationError{ 12402 Err: fmt.Errorf("failed to decode response body, %w", err), 12403 Snapshot: snapshot.Bytes(), 12404 } 12405 } 12406 12407 return output 12408} 12409 12410func awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12411 output := &types.TooManyVPCAssociationAuthorizations{} 12412 var buff [1024]byte 12413 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12414 body := io.TeeReader(errorBody, ringBuffer) 12415 rootDecoder := xml.NewDecoder(body) 12416 t, err := smithyxml.FetchRootElement(rootDecoder) 12417 if err == io.EOF { 12418 return output 12419 } 12420 if err != nil { 12421 var snapshot bytes.Buffer 12422 io.Copy(&snapshot, ringBuffer) 12423 return &smithy.DeserializationError{ 12424 Err: fmt.Errorf("failed to decode response body, %w", err), 12425 Snapshot: snapshot.Bytes(), 12426 } 12427 } 12428 12429 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12430 t, err = decoder.GetElement("Error") 12431 if err != nil { 12432 var snapshot bytes.Buffer 12433 io.Copy(&snapshot, ringBuffer) 12434 return &smithy.DeserializationError{ 12435 Err: fmt.Errorf("failed to decode response body, %w", err), 12436 Snapshot: snapshot.Bytes(), 12437 } 12438 } 12439 12440 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12441 err = awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(&output, decoder) 12442 if err != nil { 12443 var snapshot bytes.Buffer 12444 io.Copy(&snapshot, ringBuffer) 12445 return &smithy.DeserializationError{ 12446 Err: fmt.Errorf("failed to decode response body, %w", err), 12447 Snapshot: snapshot.Bytes(), 12448 } 12449 } 12450 12451 return output 12452} 12453 12454func awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12455 output := &types.TrafficPolicyAlreadyExists{} 12456 var buff [1024]byte 12457 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12458 body := io.TeeReader(errorBody, ringBuffer) 12459 rootDecoder := xml.NewDecoder(body) 12460 t, err := smithyxml.FetchRootElement(rootDecoder) 12461 if err == io.EOF { 12462 return output 12463 } 12464 if err != nil { 12465 var snapshot bytes.Buffer 12466 io.Copy(&snapshot, ringBuffer) 12467 return &smithy.DeserializationError{ 12468 Err: fmt.Errorf("failed to decode response body, %w", err), 12469 Snapshot: snapshot.Bytes(), 12470 } 12471 } 12472 12473 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12474 t, err = decoder.GetElement("Error") 12475 if err != nil { 12476 var snapshot bytes.Buffer 12477 io.Copy(&snapshot, ringBuffer) 12478 return &smithy.DeserializationError{ 12479 Err: fmt.Errorf("failed to decode response body, %w", err), 12480 Snapshot: snapshot.Bytes(), 12481 } 12482 } 12483 12484 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12485 err = awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(&output, decoder) 12486 if err != nil { 12487 var snapshot bytes.Buffer 12488 io.Copy(&snapshot, ringBuffer) 12489 return &smithy.DeserializationError{ 12490 Err: fmt.Errorf("failed to decode response body, %w", err), 12491 Snapshot: snapshot.Bytes(), 12492 } 12493 } 12494 12495 return output 12496} 12497 12498func awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12499 output := &types.TrafficPolicyInstanceAlreadyExists{} 12500 var buff [1024]byte 12501 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12502 body := io.TeeReader(errorBody, ringBuffer) 12503 rootDecoder := xml.NewDecoder(body) 12504 t, err := smithyxml.FetchRootElement(rootDecoder) 12505 if err == io.EOF { 12506 return output 12507 } 12508 if err != nil { 12509 var snapshot bytes.Buffer 12510 io.Copy(&snapshot, ringBuffer) 12511 return &smithy.DeserializationError{ 12512 Err: fmt.Errorf("failed to decode response body, %w", err), 12513 Snapshot: snapshot.Bytes(), 12514 } 12515 } 12516 12517 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12518 t, err = decoder.GetElement("Error") 12519 if err != nil { 12520 var snapshot bytes.Buffer 12521 io.Copy(&snapshot, ringBuffer) 12522 return &smithy.DeserializationError{ 12523 Err: fmt.Errorf("failed to decode response body, %w", err), 12524 Snapshot: snapshot.Bytes(), 12525 } 12526 } 12527 12528 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12529 err = awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(&output, decoder) 12530 if err != nil { 12531 var snapshot bytes.Buffer 12532 io.Copy(&snapshot, ringBuffer) 12533 return &smithy.DeserializationError{ 12534 Err: fmt.Errorf("failed to decode response body, %w", err), 12535 Snapshot: snapshot.Bytes(), 12536 } 12537 } 12538 12539 return output 12540} 12541 12542func awsRestxml_deserializeErrorTrafficPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12543 output := &types.TrafficPolicyInUse{} 12544 var buff [1024]byte 12545 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12546 body := io.TeeReader(errorBody, ringBuffer) 12547 rootDecoder := xml.NewDecoder(body) 12548 t, err := smithyxml.FetchRootElement(rootDecoder) 12549 if err == io.EOF { 12550 return output 12551 } 12552 if err != nil { 12553 var snapshot bytes.Buffer 12554 io.Copy(&snapshot, ringBuffer) 12555 return &smithy.DeserializationError{ 12556 Err: fmt.Errorf("failed to decode response body, %w", err), 12557 Snapshot: snapshot.Bytes(), 12558 } 12559 } 12560 12561 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12562 t, err = decoder.GetElement("Error") 12563 if err != nil { 12564 var snapshot bytes.Buffer 12565 io.Copy(&snapshot, ringBuffer) 12566 return &smithy.DeserializationError{ 12567 Err: fmt.Errorf("failed to decode response body, %w", err), 12568 Snapshot: snapshot.Bytes(), 12569 } 12570 } 12571 12572 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12573 err = awsRestxml_deserializeDocumentTrafficPolicyInUse(&output, decoder) 12574 if err != nil { 12575 var snapshot bytes.Buffer 12576 io.Copy(&snapshot, ringBuffer) 12577 return &smithy.DeserializationError{ 12578 Err: fmt.Errorf("failed to decode response body, %w", err), 12579 Snapshot: snapshot.Bytes(), 12580 } 12581 } 12582 12583 return output 12584} 12585 12586func awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12587 output := &types.VPCAssociationAuthorizationNotFound{} 12588 var buff [1024]byte 12589 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12590 body := io.TeeReader(errorBody, ringBuffer) 12591 rootDecoder := xml.NewDecoder(body) 12592 t, err := smithyxml.FetchRootElement(rootDecoder) 12593 if err == io.EOF { 12594 return output 12595 } 12596 if err != nil { 12597 var snapshot bytes.Buffer 12598 io.Copy(&snapshot, ringBuffer) 12599 return &smithy.DeserializationError{ 12600 Err: fmt.Errorf("failed to decode response body, %w", err), 12601 Snapshot: snapshot.Bytes(), 12602 } 12603 } 12604 12605 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12606 t, err = decoder.GetElement("Error") 12607 if err != nil { 12608 var snapshot bytes.Buffer 12609 io.Copy(&snapshot, ringBuffer) 12610 return &smithy.DeserializationError{ 12611 Err: fmt.Errorf("failed to decode response body, %w", err), 12612 Snapshot: snapshot.Bytes(), 12613 } 12614 } 12615 12616 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12617 err = awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(&output, decoder) 12618 if err != nil { 12619 var snapshot bytes.Buffer 12620 io.Copy(&snapshot, ringBuffer) 12621 return &smithy.DeserializationError{ 12622 Err: fmt.Errorf("failed to decode response body, %w", err), 12623 Snapshot: snapshot.Bytes(), 12624 } 12625 } 12626 12627 return output 12628} 12629 12630func awsRestxml_deserializeErrorVPCAssociationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 12631 output := &types.VPCAssociationNotFound{} 12632 var buff [1024]byte 12633 ringBuffer := smithyio.NewRingBuffer(buff[:]) 12634 body := io.TeeReader(errorBody, ringBuffer) 12635 rootDecoder := xml.NewDecoder(body) 12636 t, err := smithyxml.FetchRootElement(rootDecoder) 12637 if err == io.EOF { 12638 return output 12639 } 12640 if err != nil { 12641 var snapshot bytes.Buffer 12642 io.Copy(&snapshot, ringBuffer) 12643 return &smithy.DeserializationError{ 12644 Err: fmt.Errorf("failed to decode response body, %w", err), 12645 Snapshot: snapshot.Bytes(), 12646 } 12647 } 12648 12649 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 12650 t, err = decoder.GetElement("Error") 12651 if err != nil { 12652 var snapshot bytes.Buffer 12653 io.Copy(&snapshot, ringBuffer) 12654 return &smithy.DeserializationError{ 12655 Err: fmt.Errorf("failed to decode response body, %w", err), 12656 Snapshot: snapshot.Bytes(), 12657 } 12658 } 12659 12660 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12661 err = awsRestxml_deserializeDocumentVPCAssociationNotFound(&output, decoder) 12662 if err != nil { 12663 var snapshot bytes.Buffer 12664 io.Copy(&snapshot, ringBuffer) 12665 return &smithy.DeserializationError{ 12666 Err: fmt.Errorf("failed to decode response body, %w", err), 12667 Snapshot: snapshot.Bytes(), 12668 } 12669 } 12670 12671 return output 12672} 12673 12674func awsRestxml_deserializeDocumentAccountLimit(v **types.AccountLimit, decoder smithyxml.NodeDecoder) error { 12675 if v == nil { 12676 return fmt.Errorf("unexpected nil of type %T", v) 12677 } 12678 var sv *types.AccountLimit 12679 if *v == nil { 12680 sv = &types.AccountLimit{} 12681 } else { 12682 sv = *v 12683 } 12684 12685 for { 12686 t, done, err := decoder.Token() 12687 if err != nil { 12688 return err 12689 } 12690 if done { 12691 break 12692 } 12693 originalDecoder := decoder 12694 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12695 switch { 12696 case strings.EqualFold("Type", t.Name.Local): 12697 val, err := decoder.Value() 12698 if err != nil { 12699 return err 12700 } 12701 if val == nil { 12702 break 12703 } 12704 { 12705 xtv := string(val) 12706 sv.Type = types.AccountLimitType(xtv) 12707 } 12708 12709 case strings.EqualFold("Value", t.Name.Local): 12710 val, err := decoder.Value() 12711 if err != nil { 12712 return err 12713 } 12714 if val == nil { 12715 break 12716 } 12717 { 12718 xtv := string(val) 12719 i64, err := strconv.ParseInt(xtv, 10, 64) 12720 if err != nil { 12721 return err 12722 } 12723 sv.Value = i64 12724 } 12725 12726 default: 12727 // Do nothing and ignore the unexpected tag element 12728 err = decoder.Decoder.Skip() 12729 if err != nil { 12730 return err 12731 } 12732 12733 } 12734 decoder = originalDecoder 12735 } 12736 *v = sv 12737 return nil 12738} 12739 12740func awsRestxml_deserializeDocumentAlarmIdentifier(v **types.AlarmIdentifier, decoder smithyxml.NodeDecoder) error { 12741 if v == nil { 12742 return fmt.Errorf("unexpected nil of type %T", v) 12743 } 12744 var sv *types.AlarmIdentifier 12745 if *v == nil { 12746 sv = &types.AlarmIdentifier{} 12747 } else { 12748 sv = *v 12749 } 12750 12751 for { 12752 t, done, err := decoder.Token() 12753 if err != nil { 12754 return err 12755 } 12756 if done { 12757 break 12758 } 12759 originalDecoder := decoder 12760 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12761 switch { 12762 case strings.EqualFold("Name", t.Name.Local): 12763 val, err := decoder.Value() 12764 if err != nil { 12765 return err 12766 } 12767 if val == nil { 12768 break 12769 } 12770 { 12771 xtv := string(val) 12772 sv.Name = ptr.String(xtv) 12773 } 12774 12775 case strings.EqualFold("Region", t.Name.Local): 12776 val, err := decoder.Value() 12777 if err != nil { 12778 return err 12779 } 12780 if val == nil { 12781 break 12782 } 12783 { 12784 xtv := string(val) 12785 sv.Region = types.CloudWatchRegion(xtv) 12786 } 12787 12788 default: 12789 // Do nothing and ignore the unexpected tag element 12790 err = decoder.Decoder.Skip() 12791 if err != nil { 12792 return err 12793 } 12794 12795 } 12796 decoder = originalDecoder 12797 } 12798 *v = sv 12799 return nil 12800} 12801 12802func awsRestxml_deserializeDocumentAliasTarget(v **types.AliasTarget, decoder smithyxml.NodeDecoder) error { 12803 if v == nil { 12804 return fmt.Errorf("unexpected nil of type %T", v) 12805 } 12806 var sv *types.AliasTarget 12807 if *v == nil { 12808 sv = &types.AliasTarget{} 12809 } else { 12810 sv = *v 12811 } 12812 12813 for { 12814 t, done, err := decoder.Token() 12815 if err != nil { 12816 return err 12817 } 12818 if done { 12819 break 12820 } 12821 originalDecoder := decoder 12822 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12823 switch { 12824 case strings.EqualFold("DNSName", t.Name.Local): 12825 val, err := decoder.Value() 12826 if err != nil { 12827 return err 12828 } 12829 if val == nil { 12830 break 12831 } 12832 { 12833 xtv := string(val) 12834 sv.DNSName = ptr.String(xtv) 12835 } 12836 12837 case strings.EqualFold("EvaluateTargetHealth", t.Name.Local): 12838 val, err := decoder.Value() 12839 if err != nil { 12840 return err 12841 } 12842 if val == nil { 12843 break 12844 } 12845 { 12846 xtv, err := strconv.ParseBool(string(val)) 12847 if err != nil { 12848 return fmt.Errorf("expected AliasHealthEnabled to be of type *bool, got %T instead", val) 12849 } 12850 sv.EvaluateTargetHealth = xtv 12851 } 12852 12853 case strings.EqualFold("HostedZoneId", t.Name.Local): 12854 val, err := decoder.Value() 12855 if err != nil { 12856 return err 12857 } 12858 if val == nil { 12859 break 12860 } 12861 { 12862 xtv := string(val) 12863 sv.HostedZoneId = ptr.String(xtv) 12864 } 12865 12866 default: 12867 // Do nothing and ignore the unexpected tag element 12868 err = decoder.Decoder.Skip() 12869 if err != nil { 12870 return err 12871 } 12872 12873 } 12874 decoder = originalDecoder 12875 } 12876 *v = sv 12877 return nil 12878} 12879 12880func awsRestxml_deserializeDocumentChangeInfo(v **types.ChangeInfo, decoder smithyxml.NodeDecoder) error { 12881 if v == nil { 12882 return fmt.Errorf("unexpected nil of type %T", v) 12883 } 12884 var sv *types.ChangeInfo 12885 if *v == nil { 12886 sv = &types.ChangeInfo{} 12887 } else { 12888 sv = *v 12889 } 12890 12891 for { 12892 t, done, err := decoder.Token() 12893 if err != nil { 12894 return err 12895 } 12896 if done { 12897 break 12898 } 12899 originalDecoder := decoder 12900 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12901 switch { 12902 case strings.EqualFold("Comment", t.Name.Local): 12903 val, err := decoder.Value() 12904 if err != nil { 12905 return err 12906 } 12907 if val == nil { 12908 break 12909 } 12910 { 12911 xtv := string(val) 12912 sv.Comment = ptr.String(xtv) 12913 } 12914 12915 case strings.EqualFold("Id", t.Name.Local): 12916 val, err := decoder.Value() 12917 if err != nil { 12918 return err 12919 } 12920 if val == nil { 12921 break 12922 } 12923 { 12924 xtv := string(val) 12925 sv.Id = ptr.String(xtv) 12926 } 12927 12928 case strings.EqualFold("Status", t.Name.Local): 12929 val, err := decoder.Value() 12930 if err != nil { 12931 return err 12932 } 12933 if val == nil { 12934 break 12935 } 12936 { 12937 xtv := string(val) 12938 sv.Status = types.ChangeStatus(xtv) 12939 } 12940 12941 case strings.EqualFold("SubmittedAt", t.Name.Local): 12942 val, err := decoder.Value() 12943 if err != nil { 12944 return err 12945 } 12946 if val == nil { 12947 break 12948 } 12949 { 12950 xtv := string(val) 12951 t, err := smithytime.ParseDateTime(xtv) 12952 if err != nil { 12953 return err 12954 } 12955 sv.SubmittedAt = ptr.Time(t) 12956 } 12957 12958 default: 12959 // Do nothing and ignore the unexpected tag element 12960 err = decoder.Decoder.Skip() 12961 if err != nil { 12962 return err 12963 } 12964 12965 } 12966 decoder = originalDecoder 12967 } 12968 *v = sv 12969 return nil 12970} 12971 12972func awsRestxml_deserializeDocumentCheckerIpRanges(v *[]string, decoder smithyxml.NodeDecoder) error { 12973 if v == nil { 12974 return fmt.Errorf("unexpected nil of type %T", v) 12975 } 12976 var sv []string 12977 if *v == nil { 12978 sv = make([]string, 0) 12979 } else { 12980 sv = *v 12981 } 12982 12983 originalDecoder := decoder 12984 for { 12985 t, done, err := decoder.Token() 12986 if err != nil { 12987 return err 12988 } 12989 if done { 12990 break 12991 } 12992 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12993 decoder = memberDecoder 12994 switch { 12995 case strings.EqualFold("member", t.Name.Local): 12996 var col string 12997 val, err := decoder.Value() 12998 if err != nil { 12999 return err 13000 } 13001 if val == nil { 13002 break 13003 } 13004 { 13005 xtv := string(val) 13006 col = xtv 13007 } 13008 sv = append(sv, col) 13009 13010 default: 13011 err = decoder.Decoder.Skip() 13012 if err != nil { 13013 return err 13014 } 13015 13016 } 13017 decoder = originalDecoder 13018 } 13019 *v = sv 13020 return nil 13021} 13022 13023func awsRestxml_deserializeDocumentCheckerIpRangesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13024 var sv []string 13025 if *v == nil { 13026 sv = make([]string, 0) 13027 } else { 13028 sv = *v 13029 } 13030 13031 switch { 13032 default: 13033 var mv string 13034 t := decoder.StartEl 13035 _ = t 13036 val, err := decoder.Value() 13037 if err != nil { 13038 return err 13039 } 13040 if val == nil { 13041 break 13042 } 13043 { 13044 xtv := string(val) 13045 mv = xtv 13046 } 13047 sv = append(sv, mv) 13048 } 13049 *v = sv 13050 return nil 13051} 13052func awsRestxml_deserializeDocumentChildHealthCheckList(v *[]string, decoder smithyxml.NodeDecoder) error { 13053 if v == nil { 13054 return fmt.Errorf("unexpected nil of type %T", v) 13055 } 13056 var sv []string 13057 if *v == nil { 13058 sv = make([]string, 0) 13059 } else { 13060 sv = *v 13061 } 13062 13063 originalDecoder := decoder 13064 for { 13065 t, done, err := decoder.Token() 13066 if err != nil { 13067 return err 13068 } 13069 if done { 13070 break 13071 } 13072 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13073 decoder = memberDecoder 13074 switch { 13075 case strings.EqualFold("ChildHealthCheck", t.Name.Local): 13076 var col string 13077 val, err := decoder.Value() 13078 if err != nil { 13079 return err 13080 } 13081 if val == nil { 13082 break 13083 } 13084 { 13085 xtv := string(val) 13086 col = xtv 13087 } 13088 sv = append(sv, col) 13089 13090 default: 13091 err = decoder.Decoder.Skip() 13092 if err != nil { 13093 return err 13094 } 13095 13096 } 13097 decoder = originalDecoder 13098 } 13099 *v = sv 13100 return nil 13101} 13102 13103func awsRestxml_deserializeDocumentChildHealthCheckListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13104 var sv []string 13105 if *v == nil { 13106 sv = make([]string, 0) 13107 } else { 13108 sv = *v 13109 } 13110 13111 switch { 13112 default: 13113 var mv string 13114 t := decoder.StartEl 13115 _ = t 13116 val, err := decoder.Value() 13117 if err != nil { 13118 return err 13119 } 13120 if val == nil { 13121 break 13122 } 13123 { 13124 xtv := string(val) 13125 mv = xtv 13126 } 13127 sv = append(sv, mv) 13128 } 13129 *v = sv 13130 return nil 13131} 13132func awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(v **types.CloudWatchAlarmConfiguration, decoder smithyxml.NodeDecoder) error { 13133 if v == nil { 13134 return fmt.Errorf("unexpected nil of type %T", v) 13135 } 13136 var sv *types.CloudWatchAlarmConfiguration 13137 if *v == nil { 13138 sv = &types.CloudWatchAlarmConfiguration{} 13139 } else { 13140 sv = *v 13141 } 13142 13143 for { 13144 t, done, err := decoder.Token() 13145 if err != nil { 13146 return err 13147 } 13148 if done { 13149 break 13150 } 13151 originalDecoder := decoder 13152 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13153 switch { 13154 case strings.EqualFold("ComparisonOperator", t.Name.Local): 13155 val, err := decoder.Value() 13156 if err != nil { 13157 return err 13158 } 13159 if val == nil { 13160 break 13161 } 13162 { 13163 xtv := string(val) 13164 sv.ComparisonOperator = types.ComparisonOperator(xtv) 13165 } 13166 13167 case strings.EqualFold("Dimensions", t.Name.Local): 13168 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13169 if err := awsRestxml_deserializeDocumentDimensionList(&sv.Dimensions, nodeDecoder); err != nil { 13170 return err 13171 } 13172 13173 case strings.EqualFold("EvaluationPeriods", t.Name.Local): 13174 val, err := decoder.Value() 13175 if err != nil { 13176 return err 13177 } 13178 if val == nil { 13179 break 13180 } 13181 { 13182 xtv := string(val) 13183 i64, err := strconv.ParseInt(xtv, 10, 64) 13184 if err != nil { 13185 return err 13186 } 13187 sv.EvaluationPeriods = ptr.Int32(int32(i64)) 13188 } 13189 13190 case strings.EqualFold("MetricName", t.Name.Local): 13191 val, err := decoder.Value() 13192 if err != nil { 13193 return err 13194 } 13195 if val == nil { 13196 break 13197 } 13198 { 13199 xtv := string(val) 13200 sv.MetricName = ptr.String(xtv) 13201 } 13202 13203 case strings.EqualFold("Namespace", t.Name.Local): 13204 val, err := decoder.Value() 13205 if err != nil { 13206 return err 13207 } 13208 if val == nil { 13209 break 13210 } 13211 { 13212 xtv := string(val) 13213 sv.Namespace = ptr.String(xtv) 13214 } 13215 13216 case strings.EqualFold("Period", t.Name.Local): 13217 val, err := decoder.Value() 13218 if err != nil { 13219 return err 13220 } 13221 if val == nil { 13222 break 13223 } 13224 { 13225 xtv := string(val) 13226 i64, err := strconv.ParseInt(xtv, 10, 64) 13227 if err != nil { 13228 return err 13229 } 13230 sv.Period = ptr.Int32(int32(i64)) 13231 } 13232 13233 case strings.EqualFold("Statistic", t.Name.Local): 13234 val, err := decoder.Value() 13235 if err != nil { 13236 return err 13237 } 13238 if val == nil { 13239 break 13240 } 13241 { 13242 xtv := string(val) 13243 sv.Statistic = types.Statistic(xtv) 13244 } 13245 13246 case strings.EqualFold("Threshold", t.Name.Local): 13247 val, err := decoder.Value() 13248 if err != nil { 13249 return err 13250 } 13251 if val == nil { 13252 break 13253 } 13254 { 13255 xtv := string(val) 13256 f64, err := strconv.ParseFloat(xtv, 64) 13257 if err != nil { 13258 return err 13259 } 13260 sv.Threshold = ptr.Float64(f64) 13261 } 13262 13263 default: 13264 // Do nothing and ignore the unexpected tag element 13265 err = decoder.Decoder.Skip() 13266 if err != nil { 13267 return err 13268 } 13269 13270 } 13271 decoder = originalDecoder 13272 } 13273 *v = sv 13274 return nil 13275} 13276 13277func awsRestxml_deserializeDocumentConcurrentModification(v **types.ConcurrentModification, decoder smithyxml.NodeDecoder) error { 13278 if v == nil { 13279 return fmt.Errorf("unexpected nil of type %T", v) 13280 } 13281 var sv *types.ConcurrentModification 13282 if *v == nil { 13283 sv = &types.ConcurrentModification{} 13284 } else { 13285 sv = *v 13286 } 13287 13288 for { 13289 t, done, err := decoder.Token() 13290 if err != nil { 13291 return err 13292 } 13293 if done { 13294 break 13295 } 13296 originalDecoder := decoder 13297 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13298 switch { 13299 case strings.EqualFold("message", t.Name.Local): 13300 val, err := decoder.Value() 13301 if err != nil { 13302 return err 13303 } 13304 if val == nil { 13305 break 13306 } 13307 { 13308 xtv := string(val) 13309 sv.Message = ptr.String(xtv) 13310 } 13311 13312 default: 13313 // Do nothing and ignore the unexpected tag element 13314 err = decoder.Decoder.Skip() 13315 if err != nil { 13316 return err 13317 } 13318 13319 } 13320 decoder = originalDecoder 13321 } 13322 *v = sv 13323 return nil 13324} 13325 13326func awsRestxml_deserializeDocumentConflictingDomainExists(v **types.ConflictingDomainExists, decoder smithyxml.NodeDecoder) error { 13327 if v == nil { 13328 return fmt.Errorf("unexpected nil of type %T", v) 13329 } 13330 var sv *types.ConflictingDomainExists 13331 if *v == nil { 13332 sv = &types.ConflictingDomainExists{} 13333 } else { 13334 sv = *v 13335 } 13336 13337 for { 13338 t, done, err := decoder.Token() 13339 if err != nil { 13340 return err 13341 } 13342 if done { 13343 break 13344 } 13345 originalDecoder := decoder 13346 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13347 switch { 13348 case strings.EqualFold("message", t.Name.Local): 13349 val, err := decoder.Value() 13350 if err != nil { 13351 return err 13352 } 13353 if val == nil { 13354 break 13355 } 13356 { 13357 xtv := string(val) 13358 sv.Message = ptr.String(xtv) 13359 } 13360 13361 default: 13362 // Do nothing and ignore the unexpected tag element 13363 err = decoder.Decoder.Skip() 13364 if err != nil { 13365 return err 13366 } 13367 13368 } 13369 decoder = originalDecoder 13370 } 13371 *v = sv 13372 return nil 13373} 13374 13375func awsRestxml_deserializeDocumentConflictingTypes(v **types.ConflictingTypes, decoder smithyxml.NodeDecoder) error { 13376 if v == nil { 13377 return fmt.Errorf("unexpected nil of type %T", v) 13378 } 13379 var sv *types.ConflictingTypes 13380 if *v == nil { 13381 sv = &types.ConflictingTypes{} 13382 } else { 13383 sv = *v 13384 } 13385 13386 for { 13387 t, done, err := decoder.Token() 13388 if err != nil { 13389 return err 13390 } 13391 if done { 13392 break 13393 } 13394 originalDecoder := decoder 13395 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13396 switch { 13397 case strings.EqualFold("message", t.Name.Local): 13398 val, err := decoder.Value() 13399 if err != nil { 13400 return err 13401 } 13402 if val == nil { 13403 break 13404 } 13405 { 13406 xtv := string(val) 13407 sv.Message = ptr.String(xtv) 13408 } 13409 13410 default: 13411 // Do nothing and ignore the unexpected tag element 13412 err = decoder.Decoder.Skip() 13413 if err != nil { 13414 return err 13415 } 13416 13417 } 13418 decoder = originalDecoder 13419 } 13420 *v = sv 13421 return nil 13422} 13423 13424func awsRestxml_deserializeDocumentDelegationSet(v **types.DelegationSet, decoder smithyxml.NodeDecoder) error { 13425 if v == nil { 13426 return fmt.Errorf("unexpected nil of type %T", v) 13427 } 13428 var sv *types.DelegationSet 13429 if *v == nil { 13430 sv = &types.DelegationSet{} 13431 } else { 13432 sv = *v 13433 } 13434 13435 for { 13436 t, done, err := decoder.Token() 13437 if err != nil { 13438 return err 13439 } 13440 if done { 13441 break 13442 } 13443 originalDecoder := decoder 13444 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13445 switch { 13446 case strings.EqualFold("CallerReference", t.Name.Local): 13447 val, err := decoder.Value() 13448 if err != nil { 13449 return err 13450 } 13451 if val == nil { 13452 break 13453 } 13454 { 13455 xtv := string(val) 13456 sv.CallerReference = ptr.String(xtv) 13457 } 13458 13459 case strings.EqualFold("Id", t.Name.Local): 13460 val, err := decoder.Value() 13461 if err != nil { 13462 return err 13463 } 13464 if val == nil { 13465 break 13466 } 13467 { 13468 xtv := string(val) 13469 sv.Id = ptr.String(xtv) 13470 } 13471 13472 case strings.EqualFold("NameServers", t.Name.Local): 13473 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13474 if err := awsRestxml_deserializeDocumentDelegationSetNameServers(&sv.NameServers, nodeDecoder); err != nil { 13475 return err 13476 } 13477 13478 default: 13479 // Do nothing and ignore the unexpected tag element 13480 err = decoder.Decoder.Skip() 13481 if err != nil { 13482 return err 13483 } 13484 13485 } 13486 decoder = originalDecoder 13487 } 13488 *v = sv 13489 return nil 13490} 13491 13492func awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(v **types.DelegationSetAlreadyCreated, decoder smithyxml.NodeDecoder) error { 13493 if v == nil { 13494 return fmt.Errorf("unexpected nil of type %T", v) 13495 } 13496 var sv *types.DelegationSetAlreadyCreated 13497 if *v == nil { 13498 sv = &types.DelegationSetAlreadyCreated{} 13499 } else { 13500 sv = *v 13501 } 13502 13503 for { 13504 t, done, err := decoder.Token() 13505 if err != nil { 13506 return err 13507 } 13508 if done { 13509 break 13510 } 13511 originalDecoder := decoder 13512 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13513 switch { 13514 case strings.EqualFold("message", t.Name.Local): 13515 val, err := decoder.Value() 13516 if err != nil { 13517 return err 13518 } 13519 if val == nil { 13520 break 13521 } 13522 { 13523 xtv := string(val) 13524 sv.Message = ptr.String(xtv) 13525 } 13526 13527 default: 13528 // Do nothing and ignore the unexpected tag element 13529 err = decoder.Decoder.Skip() 13530 if err != nil { 13531 return err 13532 } 13533 13534 } 13535 decoder = originalDecoder 13536 } 13537 *v = sv 13538 return nil 13539} 13540 13541func awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(v **types.DelegationSetAlreadyReusable, decoder smithyxml.NodeDecoder) error { 13542 if v == nil { 13543 return fmt.Errorf("unexpected nil of type %T", v) 13544 } 13545 var sv *types.DelegationSetAlreadyReusable 13546 if *v == nil { 13547 sv = &types.DelegationSetAlreadyReusable{} 13548 } else { 13549 sv = *v 13550 } 13551 13552 for { 13553 t, done, err := decoder.Token() 13554 if err != nil { 13555 return err 13556 } 13557 if done { 13558 break 13559 } 13560 originalDecoder := decoder 13561 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13562 switch { 13563 case strings.EqualFold("message", t.Name.Local): 13564 val, err := decoder.Value() 13565 if err != nil { 13566 return err 13567 } 13568 if val == nil { 13569 break 13570 } 13571 { 13572 xtv := string(val) 13573 sv.Message = ptr.String(xtv) 13574 } 13575 13576 default: 13577 // Do nothing and ignore the unexpected tag element 13578 err = decoder.Decoder.Skip() 13579 if err != nil { 13580 return err 13581 } 13582 13583 } 13584 decoder = originalDecoder 13585 } 13586 *v = sv 13587 return nil 13588} 13589 13590func awsRestxml_deserializeDocumentDelegationSetInUse(v **types.DelegationSetInUse, decoder smithyxml.NodeDecoder) error { 13591 if v == nil { 13592 return fmt.Errorf("unexpected nil of type %T", v) 13593 } 13594 var sv *types.DelegationSetInUse 13595 if *v == nil { 13596 sv = &types.DelegationSetInUse{} 13597 } else { 13598 sv = *v 13599 } 13600 13601 for { 13602 t, done, err := decoder.Token() 13603 if err != nil { 13604 return err 13605 } 13606 if done { 13607 break 13608 } 13609 originalDecoder := decoder 13610 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13611 switch { 13612 case strings.EqualFold("message", t.Name.Local): 13613 val, err := decoder.Value() 13614 if err != nil { 13615 return err 13616 } 13617 if val == nil { 13618 break 13619 } 13620 { 13621 xtv := string(val) 13622 sv.Message = ptr.String(xtv) 13623 } 13624 13625 default: 13626 // Do nothing and ignore the unexpected tag element 13627 err = decoder.Decoder.Skip() 13628 if err != nil { 13629 return err 13630 } 13631 13632 } 13633 decoder = originalDecoder 13634 } 13635 *v = sv 13636 return nil 13637} 13638 13639func awsRestxml_deserializeDocumentDelegationSetNameServers(v *[]string, decoder smithyxml.NodeDecoder) error { 13640 if v == nil { 13641 return fmt.Errorf("unexpected nil of type %T", v) 13642 } 13643 var sv []string 13644 if *v == nil { 13645 sv = make([]string, 0) 13646 } else { 13647 sv = *v 13648 } 13649 13650 originalDecoder := decoder 13651 for { 13652 t, done, err := decoder.Token() 13653 if err != nil { 13654 return err 13655 } 13656 if done { 13657 break 13658 } 13659 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13660 decoder = memberDecoder 13661 switch { 13662 case strings.EqualFold("NameServer", t.Name.Local): 13663 var col string 13664 val, err := decoder.Value() 13665 if err != nil { 13666 return err 13667 } 13668 if val == nil { 13669 break 13670 } 13671 { 13672 xtv := string(val) 13673 col = xtv 13674 } 13675 sv = append(sv, col) 13676 13677 default: 13678 err = decoder.Decoder.Skip() 13679 if err != nil { 13680 return err 13681 } 13682 13683 } 13684 decoder = originalDecoder 13685 } 13686 *v = sv 13687 return nil 13688} 13689 13690func awsRestxml_deserializeDocumentDelegationSetNameServersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13691 var sv []string 13692 if *v == nil { 13693 sv = make([]string, 0) 13694 } else { 13695 sv = *v 13696 } 13697 13698 switch { 13699 default: 13700 var mv string 13701 t := decoder.StartEl 13702 _ = t 13703 val, err := decoder.Value() 13704 if err != nil { 13705 return err 13706 } 13707 if val == nil { 13708 break 13709 } 13710 { 13711 xtv := string(val) 13712 mv = xtv 13713 } 13714 sv = append(sv, mv) 13715 } 13716 *v = sv 13717 return nil 13718} 13719func awsRestxml_deserializeDocumentDelegationSetNotAvailable(v **types.DelegationSetNotAvailable, decoder smithyxml.NodeDecoder) error { 13720 if v == nil { 13721 return fmt.Errorf("unexpected nil of type %T", v) 13722 } 13723 var sv *types.DelegationSetNotAvailable 13724 if *v == nil { 13725 sv = &types.DelegationSetNotAvailable{} 13726 } else { 13727 sv = *v 13728 } 13729 13730 for { 13731 t, done, err := decoder.Token() 13732 if err != nil { 13733 return err 13734 } 13735 if done { 13736 break 13737 } 13738 originalDecoder := decoder 13739 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13740 switch { 13741 case strings.EqualFold("message", t.Name.Local): 13742 val, err := decoder.Value() 13743 if err != nil { 13744 return err 13745 } 13746 if val == nil { 13747 break 13748 } 13749 { 13750 xtv := string(val) 13751 sv.Message = ptr.String(xtv) 13752 } 13753 13754 default: 13755 // Do nothing and ignore the unexpected tag element 13756 err = decoder.Decoder.Skip() 13757 if err != nil { 13758 return err 13759 } 13760 13761 } 13762 decoder = originalDecoder 13763 } 13764 *v = sv 13765 return nil 13766} 13767 13768func awsRestxml_deserializeDocumentDelegationSetNotReusable(v **types.DelegationSetNotReusable, decoder smithyxml.NodeDecoder) error { 13769 if v == nil { 13770 return fmt.Errorf("unexpected nil of type %T", v) 13771 } 13772 var sv *types.DelegationSetNotReusable 13773 if *v == nil { 13774 sv = &types.DelegationSetNotReusable{} 13775 } else { 13776 sv = *v 13777 } 13778 13779 for { 13780 t, done, err := decoder.Token() 13781 if err != nil { 13782 return err 13783 } 13784 if done { 13785 break 13786 } 13787 originalDecoder := decoder 13788 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13789 switch { 13790 case strings.EqualFold("message", t.Name.Local): 13791 val, err := decoder.Value() 13792 if err != nil { 13793 return err 13794 } 13795 if val == nil { 13796 break 13797 } 13798 { 13799 xtv := string(val) 13800 sv.Message = ptr.String(xtv) 13801 } 13802 13803 default: 13804 // Do nothing and ignore the unexpected tag element 13805 err = decoder.Decoder.Skip() 13806 if err != nil { 13807 return err 13808 } 13809 13810 } 13811 decoder = originalDecoder 13812 } 13813 *v = sv 13814 return nil 13815} 13816 13817func awsRestxml_deserializeDocumentDelegationSets(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error { 13818 if v == nil { 13819 return fmt.Errorf("unexpected nil of type %T", v) 13820 } 13821 var sv []types.DelegationSet 13822 if *v == nil { 13823 sv = make([]types.DelegationSet, 0) 13824 } else { 13825 sv = *v 13826 } 13827 13828 originalDecoder := decoder 13829 for { 13830 t, done, err := decoder.Token() 13831 if err != nil { 13832 return err 13833 } 13834 if done { 13835 break 13836 } 13837 switch { 13838 case strings.EqualFold("DelegationSet", t.Name.Local): 13839 var col types.DelegationSet 13840 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13841 destAddr := &col 13842 if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil { 13843 return err 13844 } 13845 col = *destAddr 13846 sv = append(sv, col) 13847 13848 default: 13849 err = decoder.Decoder.Skip() 13850 if err != nil { 13851 return err 13852 } 13853 13854 } 13855 decoder = originalDecoder 13856 } 13857 *v = sv 13858 return nil 13859} 13860 13861func awsRestxml_deserializeDocumentDelegationSetsUnwrapped(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error { 13862 var sv []types.DelegationSet 13863 if *v == nil { 13864 sv = make([]types.DelegationSet, 0) 13865 } else { 13866 sv = *v 13867 } 13868 13869 switch { 13870 default: 13871 var mv types.DelegationSet 13872 t := decoder.StartEl 13873 _ = t 13874 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13875 destAddr := &mv 13876 if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil { 13877 return err 13878 } 13879 mv = *destAddr 13880 sv = append(sv, mv) 13881 } 13882 *v = sv 13883 return nil 13884} 13885func awsRestxml_deserializeDocumentDimension(v **types.Dimension, decoder smithyxml.NodeDecoder) error { 13886 if v == nil { 13887 return fmt.Errorf("unexpected nil of type %T", v) 13888 } 13889 var sv *types.Dimension 13890 if *v == nil { 13891 sv = &types.Dimension{} 13892 } else { 13893 sv = *v 13894 } 13895 13896 for { 13897 t, done, err := decoder.Token() 13898 if err != nil { 13899 return err 13900 } 13901 if done { 13902 break 13903 } 13904 originalDecoder := decoder 13905 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13906 switch { 13907 case strings.EqualFold("Name", t.Name.Local): 13908 val, err := decoder.Value() 13909 if err != nil { 13910 return err 13911 } 13912 if val == nil { 13913 break 13914 } 13915 { 13916 xtv := string(val) 13917 sv.Name = ptr.String(xtv) 13918 } 13919 13920 case strings.EqualFold("Value", t.Name.Local): 13921 val, err := decoder.Value() 13922 if err != nil { 13923 return err 13924 } 13925 if val == nil { 13926 break 13927 } 13928 { 13929 xtv := string(val) 13930 sv.Value = ptr.String(xtv) 13931 } 13932 13933 default: 13934 // Do nothing and ignore the unexpected tag element 13935 err = decoder.Decoder.Skip() 13936 if err != nil { 13937 return err 13938 } 13939 13940 } 13941 decoder = originalDecoder 13942 } 13943 *v = sv 13944 return nil 13945} 13946 13947func awsRestxml_deserializeDocumentDimensionList(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error { 13948 if v == nil { 13949 return fmt.Errorf("unexpected nil of type %T", v) 13950 } 13951 var sv []types.Dimension 13952 if *v == nil { 13953 sv = make([]types.Dimension, 0) 13954 } else { 13955 sv = *v 13956 } 13957 13958 originalDecoder := decoder 13959 for { 13960 t, done, err := decoder.Token() 13961 if err != nil { 13962 return err 13963 } 13964 if done { 13965 break 13966 } 13967 switch { 13968 case strings.EqualFold("Dimension", t.Name.Local): 13969 var col types.Dimension 13970 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13971 destAddr := &col 13972 if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil { 13973 return err 13974 } 13975 col = *destAddr 13976 sv = append(sv, col) 13977 13978 default: 13979 err = decoder.Decoder.Skip() 13980 if err != nil { 13981 return err 13982 } 13983 13984 } 13985 decoder = originalDecoder 13986 } 13987 *v = sv 13988 return nil 13989} 13990 13991func awsRestxml_deserializeDocumentDimensionListUnwrapped(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error { 13992 var sv []types.Dimension 13993 if *v == nil { 13994 sv = make([]types.Dimension, 0) 13995 } else { 13996 sv = *v 13997 } 13998 13999 switch { 14000 default: 14001 var mv types.Dimension 14002 t := decoder.StartEl 14003 _ = t 14004 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14005 destAddr := &mv 14006 if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil { 14007 return err 14008 } 14009 mv = *destAddr 14010 sv = append(sv, mv) 14011 } 14012 *v = sv 14013 return nil 14014} 14015func awsRestxml_deserializeDocumentDNSSECNotFound(v **types.DNSSECNotFound, decoder smithyxml.NodeDecoder) error { 14016 if v == nil { 14017 return fmt.Errorf("unexpected nil of type %T", v) 14018 } 14019 var sv *types.DNSSECNotFound 14020 if *v == nil { 14021 sv = &types.DNSSECNotFound{} 14022 } else { 14023 sv = *v 14024 } 14025 14026 for { 14027 t, done, err := decoder.Token() 14028 if err != nil { 14029 return err 14030 } 14031 if done { 14032 break 14033 } 14034 originalDecoder := decoder 14035 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14036 switch { 14037 case strings.EqualFold("message", t.Name.Local): 14038 val, err := decoder.Value() 14039 if err != nil { 14040 return err 14041 } 14042 if val == nil { 14043 break 14044 } 14045 { 14046 xtv := string(val) 14047 sv.Message = ptr.String(xtv) 14048 } 14049 14050 default: 14051 // Do nothing and ignore the unexpected tag element 14052 err = decoder.Decoder.Skip() 14053 if err != nil { 14054 return err 14055 } 14056 14057 } 14058 decoder = originalDecoder 14059 } 14060 *v = sv 14061 return nil 14062} 14063 14064func awsRestxml_deserializeDocumentDNSSECStatus(v **types.DNSSECStatus, decoder smithyxml.NodeDecoder) error { 14065 if v == nil { 14066 return fmt.Errorf("unexpected nil of type %T", v) 14067 } 14068 var sv *types.DNSSECStatus 14069 if *v == nil { 14070 sv = &types.DNSSECStatus{} 14071 } else { 14072 sv = *v 14073 } 14074 14075 for { 14076 t, done, err := decoder.Token() 14077 if err != nil { 14078 return err 14079 } 14080 if done { 14081 break 14082 } 14083 originalDecoder := decoder 14084 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14085 switch { 14086 case strings.EqualFold("ServeSignature", t.Name.Local): 14087 val, err := decoder.Value() 14088 if err != nil { 14089 return err 14090 } 14091 if val == nil { 14092 break 14093 } 14094 { 14095 xtv := string(val) 14096 sv.ServeSignature = ptr.String(xtv) 14097 } 14098 14099 case strings.EqualFold("StatusMessage", t.Name.Local): 14100 val, err := decoder.Value() 14101 if err != nil { 14102 return err 14103 } 14104 if val == nil { 14105 break 14106 } 14107 { 14108 xtv := string(val) 14109 sv.StatusMessage = ptr.String(xtv) 14110 } 14111 14112 default: 14113 // Do nothing and ignore the unexpected tag element 14114 err = decoder.Decoder.Skip() 14115 if err != nil { 14116 return err 14117 } 14118 14119 } 14120 decoder = originalDecoder 14121 } 14122 *v = sv 14123 return nil 14124} 14125 14126func awsRestxml_deserializeDocumentErrorMessages(v *[]string, decoder smithyxml.NodeDecoder) error { 14127 if v == nil { 14128 return fmt.Errorf("unexpected nil of type %T", v) 14129 } 14130 var sv []string 14131 if *v == nil { 14132 sv = make([]string, 0) 14133 } else { 14134 sv = *v 14135 } 14136 14137 originalDecoder := decoder 14138 for { 14139 t, done, err := decoder.Token() 14140 if err != nil { 14141 return err 14142 } 14143 if done { 14144 break 14145 } 14146 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14147 decoder = memberDecoder 14148 switch { 14149 case strings.EqualFold("Message", t.Name.Local): 14150 var col string 14151 val, err := decoder.Value() 14152 if err != nil { 14153 return err 14154 } 14155 if val == nil { 14156 break 14157 } 14158 { 14159 xtv := string(val) 14160 col = xtv 14161 } 14162 sv = append(sv, col) 14163 14164 default: 14165 err = decoder.Decoder.Skip() 14166 if err != nil { 14167 return err 14168 } 14169 14170 } 14171 decoder = originalDecoder 14172 } 14173 *v = sv 14174 return nil 14175} 14176 14177func awsRestxml_deserializeDocumentErrorMessagesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 14178 var sv []string 14179 if *v == nil { 14180 sv = make([]string, 0) 14181 } else { 14182 sv = *v 14183 } 14184 14185 switch { 14186 default: 14187 var mv string 14188 t := decoder.StartEl 14189 _ = t 14190 val, err := decoder.Value() 14191 if err != nil { 14192 return err 14193 } 14194 if val == nil { 14195 break 14196 } 14197 { 14198 xtv := string(val) 14199 mv = xtv 14200 } 14201 sv = append(sv, mv) 14202 } 14203 *v = sv 14204 return nil 14205} 14206func awsRestxml_deserializeDocumentGeoLocation(v **types.GeoLocation, decoder smithyxml.NodeDecoder) error { 14207 if v == nil { 14208 return fmt.Errorf("unexpected nil of type %T", v) 14209 } 14210 var sv *types.GeoLocation 14211 if *v == nil { 14212 sv = &types.GeoLocation{} 14213 } else { 14214 sv = *v 14215 } 14216 14217 for { 14218 t, done, err := decoder.Token() 14219 if err != nil { 14220 return err 14221 } 14222 if done { 14223 break 14224 } 14225 originalDecoder := decoder 14226 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14227 switch { 14228 case strings.EqualFold("ContinentCode", t.Name.Local): 14229 val, err := decoder.Value() 14230 if err != nil { 14231 return err 14232 } 14233 if val == nil { 14234 break 14235 } 14236 { 14237 xtv := string(val) 14238 sv.ContinentCode = ptr.String(xtv) 14239 } 14240 14241 case strings.EqualFold("CountryCode", t.Name.Local): 14242 val, err := decoder.Value() 14243 if err != nil { 14244 return err 14245 } 14246 if val == nil { 14247 break 14248 } 14249 { 14250 xtv := string(val) 14251 sv.CountryCode = ptr.String(xtv) 14252 } 14253 14254 case strings.EqualFold("SubdivisionCode", t.Name.Local): 14255 val, err := decoder.Value() 14256 if err != nil { 14257 return err 14258 } 14259 if val == nil { 14260 break 14261 } 14262 { 14263 xtv := string(val) 14264 sv.SubdivisionCode = ptr.String(xtv) 14265 } 14266 14267 default: 14268 // Do nothing and ignore the unexpected tag element 14269 err = decoder.Decoder.Skip() 14270 if err != nil { 14271 return err 14272 } 14273 14274 } 14275 decoder = originalDecoder 14276 } 14277 *v = sv 14278 return nil 14279} 14280 14281func awsRestxml_deserializeDocumentGeoLocationDetails(v **types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error { 14282 if v == nil { 14283 return fmt.Errorf("unexpected nil of type %T", v) 14284 } 14285 var sv *types.GeoLocationDetails 14286 if *v == nil { 14287 sv = &types.GeoLocationDetails{} 14288 } else { 14289 sv = *v 14290 } 14291 14292 for { 14293 t, done, err := decoder.Token() 14294 if err != nil { 14295 return err 14296 } 14297 if done { 14298 break 14299 } 14300 originalDecoder := decoder 14301 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14302 switch { 14303 case strings.EqualFold("ContinentCode", t.Name.Local): 14304 val, err := decoder.Value() 14305 if err != nil { 14306 return err 14307 } 14308 if val == nil { 14309 break 14310 } 14311 { 14312 xtv := string(val) 14313 sv.ContinentCode = ptr.String(xtv) 14314 } 14315 14316 case strings.EqualFold("ContinentName", t.Name.Local): 14317 val, err := decoder.Value() 14318 if err != nil { 14319 return err 14320 } 14321 if val == nil { 14322 break 14323 } 14324 { 14325 xtv := string(val) 14326 sv.ContinentName = ptr.String(xtv) 14327 } 14328 14329 case strings.EqualFold("CountryCode", t.Name.Local): 14330 val, err := decoder.Value() 14331 if err != nil { 14332 return err 14333 } 14334 if val == nil { 14335 break 14336 } 14337 { 14338 xtv := string(val) 14339 sv.CountryCode = ptr.String(xtv) 14340 } 14341 14342 case strings.EqualFold("CountryName", t.Name.Local): 14343 val, err := decoder.Value() 14344 if err != nil { 14345 return err 14346 } 14347 if val == nil { 14348 break 14349 } 14350 { 14351 xtv := string(val) 14352 sv.CountryName = ptr.String(xtv) 14353 } 14354 14355 case strings.EqualFold("SubdivisionCode", t.Name.Local): 14356 val, err := decoder.Value() 14357 if err != nil { 14358 return err 14359 } 14360 if val == nil { 14361 break 14362 } 14363 { 14364 xtv := string(val) 14365 sv.SubdivisionCode = ptr.String(xtv) 14366 } 14367 14368 case strings.EqualFold("SubdivisionName", t.Name.Local): 14369 val, err := decoder.Value() 14370 if err != nil { 14371 return err 14372 } 14373 if val == nil { 14374 break 14375 } 14376 { 14377 xtv := string(val) 14378 sv.SubdivisionName = ptr.String(xtv) 14379 } 14380 14381 default: 14382 // Do nothing and ignore the unexpected tag element 14383 err = decoder.Decoder.Skip() 14384 if err != nil { 14385 return err 14386 } 14387 14388 } 14389 decoder = originalDecoder 14390 } 14391 *v = sv 14392 return nil 14393} 14394 14395func awsRestxml_deserializeDocumentGeoLocationDetailsList(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error { 14396 if v == nil { 14397 return fmt.Errorf("unexpected nil of type %T", v) 14398 } 14399 var sv []types.GeoLocationDetails 14400 if *v == nil { 14401 sv = make([]types.GeoLocationDetails, 0) 14402 } else { 14403 sv = *v 14404 } 14405 14406 originalDecoder := decoder 14407 for { 14408 t, done, err := decoder.Token() 14409 if err != nil { 14410 return err 14411 } 14412 if done { 14413 break 14414 } 14415 switch { 14416 case strings.EqualFold("GeoLocationDetails", t.Name.Local): 14417 var col types.GeoLocationDetails 14418 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14419 destAddr := &col 14420 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil { 14421 return err 14422 } 14423 col = *destAddr 14424 sv = append(sv, col) 14425 14426 default: 14427 err = decoder.Decoder.Skip() 14428 if err != nil { 14429 return err 14430 } 14431 14432 } 14433 decoder = originalDecoder 14434 } 14435 *v = sv 14436 return nil 14437} 14438 14439func awsRestxml_deserializeDocumentGeoLocationDetailsListUnwrapped(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error { 14440 var sv []types.GeoLocationDetails 14441 if *v == nil { 14442 sv = make([]types.GeoLocationDetails, 0) 14443 } else { 14444 sv = *v 14445 } 14446 14447 switch { 14448 default: 14449 var mv types.GeoLocationDetails 14450 t := decoder.StartEl 14451 _ = t 14452 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14453 destAddr := &mv 14454 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil { 14455 return err 14456 } 14457 mv = *destAddr 14458 sv = append(sv, mv) 14459 } 14460 *v = sv 14461 return nil 14462} 14463func awsRestxml_deserializeDocumentHealthCheck(v **types.HealthCheck, decoder smithyxml.NodeDecoder) error { 14464 if v == nil { 14465 return fmt.Errorf("unexpected nil of type %T", v) 14466 } 14467 var sv *types.HealthCheck 14468 if *v == nil { 14469 sv = &types.HealthCheck{} 14470 } else { 14471 sv = *v 14472 } 14473 14474 for { 14475 t, done, err := decoder.Token() 14476 if err != nil { 14477 return err 14478 } 14479 if done { 14480 break 14481 } 14482 originalDecoder := decoder 14483 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14484 switch { 14485 case strings.EqualFold("CallerReference", t.Name.Local): 14486 val, err := decoder.Value() 14487 if err != nil { 14488 return err 14489 } 14490 if val == nil { 14491 break 14492 } 14493 { 14494 xtv := string(val) 14495 sv.CallerReference = ptr.String(xtv) 14496 } 14497 14498 case strings.EqualFold("CloudWatchAlarmConfiguration", t.Name.Local): 14499 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14500 if err := awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(&sv.CloudWatchAlarmConfiguration, nodeDecoder); err != nil { 14501 return err 14502 } 14503 14504 case strings.EqualFold("HealthCheckConfig", t.Name.Local): 14505 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14506 if err := awsRestxml_deserializeDocumentHealthCheckConfig(&sv.HealthCheckConfig, nodeDecoder); err != nil { 14507 return err 14508 } 14509 14510 case strings.EqualFold("HealthCheckVersion", t.Name.Local): 14511 val, err := decoder.Value() 14512 if err != nil { 14513 return err 14514 } 14515 if val == nil { 14516 break 14517 } 14518 { 14519 xtv := string(val) 14520 i64, err := strconv.ParseInt(xtv, 10, 64) 14521 if err != nil { 14522 return err 14523 } 14524 sv.HealthCheckVersion = ptr.Int64(i64) 14525 } 14526 14527 case strings.EqualFold("Id", t.Name.Local): 14528 val, err := decoder.Value() 14529 if err != nil { 14530 return err 14531 } 14532 if val == nil { 14533 break 14534 } 14535 { 14536 xtv := string(val) 14537 sv.Id = ptr.String(xtv) 14538 } 14539 14540 case strings.EqualFold("LinkedService", t.Name.Local): 14541 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14542 if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil { 14543 return err 14544 } 14545 14546 default: 14547 // Do nothing and ignore the unexpected tag element 14548 err = decoder.Decoder.Skip() 14549 if err != nil { 14550 return err 14551 } 14552 14553 } 14554 decoder = originalDecoder 14555 } 14556 *v = sv 14557 return nil 14558} 14559 14560func awsRestxml_deserializeDocumentHealthCheckAlreadyExists(v **types.HealthCheckAlreadyExists, decoder smithyxml.NodeDecoder) error { 14561 if v == nil { 14562 return fmt.Errorf("unexpected nil of type %T", v) 14563 } 14564 var sv *types.HealthCheckAlreadyExists 14565 if *v == nil { 14566 sv = &types.HealthCheckAlreadyExists{} 14567 } else { 14568 sv = *v 14569 } 14570 14571 for { 14572 t, done, err := decoder.Token() 14573 if err != nil { 14574 return err 14575 } 14576 if done { 14577 break 14578 } 14579 originalDecoder := decoder 14580 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14581 switch { 14582 case strings.EqualFold("message", t.Name.Local): 14583 val, err := decoder.Value() 14584 if err != nil { 14585 return err 14586 } 14587 if val == nil { 14588 break 14589 } 14590 { 14591 xtv := string(val) 14592 sv.Message = ptr.String(xtv) 14593 } 14594 14595 default: 14596 // Do nothing and ignore the unexpected tag element 14597 err = decoder.Decoder.Skip() 14598 if err != nil { 14599 return err 14600 } 14601 14602 } 14603 decoder = originalDecoder 14604 } 14605 *v = sv 14606 return nil 14607} 14608 14609func awsRestxml_deserializeDocumentHealthCheckConfig(v **types.HealthCheckConfig, decoder smithyxml.NodeDecoder) error { 14610 if v == nil { 14611 return fmt.Errorf("unexpected nil of type %T", v) 14612 } 14613 var sv *types.HealthCheckConfig 14614 if *v == nil { 14615 sv = &types.HealthCheckConfig{} 14616 } else { 14617 sv = *v 14618 } 14619 14620 for { 14621 t, done, err := decoder.Token() 14622 if err != nil { 14623 return err 14624 } 14625 if done { 14626 break 14627 } 14628 originalDecoder := decoder 14629 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14630 switch { 14631 case strings.EqualFold("AlarmIdentifier", t.Name.Local): 14632 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14633 if err := awsRestxml_deserializeDocumentAlarmIdentifier(&sv.AlarmIdentifier, nodeDecoder); err != nil { 14634 return err 14635 } 14636 14637 case strings.EqualFold("ChildHealthChecks", t.Name.Local): 14638 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14639 if err := awsRestxml_deserializeDocumentChildHealthCheckList(&sv.ChildHealthChecks, nodeDecoder); err != nil { 14640 return err 14641 } 14642 14643 case strings.EqualFold("Disabled", t.Name.Local): 14644 val, err := decoder.Value() 14645 if err != nil { 14646 return err 14647 } 14648 if val == nil { 14649 break 14650 } 14651 { 14652 xtv, err := strconv.ParseBool(string(val)) 14653 if err != nil { 14654 return fmt.Errorf("expected Disabled to be of type *bool, got %T instead", val) 14655 } 14656 sv.Disabled = ptr.Bool(xtv) 14657 } 14658 14659 case strings.EqualFold("EnableSNI", t.Name.Local): 14660 val, err := decoder.Value() 14661 if err != nil { 14662 return err 14663 } 14664 if val == nil { 14665 break 14666 } 14667 { 14668 xtv, err := strconv.ParseBool(string(val)) 14669 if err != nil { 14670 return fmt.Errorf("expected EnableSNI to be of type *bool, got %T instead", val) 14671 } 14672 sv.EnableSNI = ptr.Bool(xtv) 14673 } 14674 14675 case strings.EqualFold("FailureThreshold", t.Name.Local): 14676 val, err := decoder.Value() 14677 if err != nil { 14678 return err 14679 } 14680 if val == nil { 14681 break 14682 } 14683 { 14684 xtv := string(val) 14685 i64, err := strconv.ParseInt(xtv, 10, 64) 14686 if err != nil { 14687 return err 14688 } 14689 sv.FailureThreshold = ptr.Int32(int32(i64)) 14690 } 14691 14692 case strings.EqualFold("FullyQualifiedDomainName", t.Name.Local): 14693 val, err := decoder.Value() 14694 if err != nil { 14695 return err 14696 } 14697 if val == nil { 14698 break 14699 } 14700 { 14701 xtv := string(val) 14702 sv.FullyQualifiedDomainName = ptr.String(xtv) 14703 } 14704 14705 case strings.EqualFold("HealthThreshold", t.Name.Local): 14706 val, err := decoder.Value() 14707 if err != nil { 14708 return err 14709 } 14710 if val == nil { 14711 break 14712 } 14713 { 14714 xtv := string(val) 14715 i64, err := strconv.ParseInt(xtv, 10, 64) 14716 if err != nil { 14717 return err 14718 } 14719 sv.HealthThreshold = ptr.Int32(int32(i64)) 14720 } 14721 14722 case strings.EqualFold("InsufficientDataHealthStatus", t.Name.Local): 14723 val, err := decoder.Value() 14724 if err != nil { 14725 return err 14726 } 14727 if val == nil { 14728 break 14729 } 14730 { 14731 xtv := string(val) 14732 sv.InsufficientDataHealthStatus = types.InsufficientDataHealthStatus(xtv) 14733 } 14734 14735 case strings.EqualFold("Inverted", t.Name.Local): 14736 val, err := decoder.Value() 14737 if err != nil { 14738 return err 14739 } 14740 if val == nil { 14741 break 14742 } 14743 { 14744 xtv, err := strconv.ParseBool(string(val)) 14745 if err != nil { 14746 return fmt.Errorf("expected Inverted to be of type *bool, got %T instead", val) 14747 } 14748 sv.Inverted = ptr.Bool(xtv) 14749 } 14750 14751 case strings.EqualFold("IPAddress", t.Name.Local): 14752 val, err := decoder.Value() 14753 if err != nil { 14754 return err 14755 } 14756 if val == nil { 14757 break 14758 } 14759 { 14760 xtv := string(val) 14761 sv.IPAddress = ptr.String(xtv) 14762 } 14763 14764 case strings.EqualFold("MeasureLatency", t.Name.Local): 14765 val, err := decoder.Value() 14766 if err != nil { 14767 return err 14768 } 14769 if val == nil { 14770 break 14771 } 14772 { 14773 xtv, err := strconv.ParseBool(string(val)) 14774 if err != nil { 14775 return fmt.Errorf("expected MeasureLatency to be of type *bool, got %T instead", val) 14776 } 14777 sv.MeasureLatency = ptr.Bool(xtv) 14778 } 14779 14780 case strings.EqualFold("Port", t.Name.Local): 14781 val, err := decoder.Value() 14782 if err != nil { 14783 return err 14784 } 14785 if val == nil { 14786 break 14787 } 14788 { 14789 xtv := string(val) 14790 i64, err := strconv.ParseInt(xtv, 10, 64) 14791 if err != nil { 14792 return err 14793 } 14794 sv.Port = ptr.Int32(int32(i64)) 14795 } 14796 14797 case strings.EqualFold("Regions", t.Name.Local): 14798 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14799 if err := awsRestxml_deserializeDocumentHealthCheckRegionList(&sv.Regions, nodeDecoder); err != nil { 14800 return err 14801 } 14802 14803 case strings.EqualFold("RequestInterval", t.Name.Local): 14804 val, err := decoder.Value() 14805 if err != nil { 14806 return err 14807 } 14808 if val == nil { 14809 break 14810 } 14811 { 14812 xtv := string(val) 14813 i64, err := strconv.ParseInt(xtv, 10, 64) 14814 if err != nil { 14815 return err 14816 } 14817 sv.RequestInterval = ptr.Int32(int32(i64)) 14818 } 14819 14820 case strings.EqualFold("ResourcePath", t.Name.Local): 14821 val, err := decoder.Value() 14822 if err != nil { 14823 return err 14824 } 14825 if val == nil { 14826 break 14827 } 14828 { 14829 xtv := string(val) 14830 sv.ResourcePath = ptr.String(xtv) 14831 } 14832 14833 case strings.EqualFold("RoutingControlArn", t.Name.Local): 14834 val, err := decoder.Value() 14835 if err != nil { 14836 return err 14837 } 14838 if val == nil { 14839 break 14840 } 14841 { 14842 xtv := string(val) 14843 sv.RoutingControlArn = ptr.String(xtv) 14844 } 14845 14846 case strings.EqualFold("SearchString", t.Name.Local): 14847 val, err := decoder.Value() 14848 if err != nil { 14849 return err 14850 } 14851 if val == nil { 14852 break 14853 } 14854 { 14855 xtv := string(val) 14856 sv.SearchString = ptr.String(xtv) 14857 } 14858 14859 case strings.EqualFold("Type", t.Name.Local): 14860 val, err := decoder.Value() 14861 if err != nil { 14862 return err 14863 } 14864 if val == nil { 14865 break 14866 } 14867 { 14868 xtv := string(val) 14869 sv.Type = types.HealthCheckType(xtv) 14870 } 14871 14872 default: 14873 // Do nothing and ignore the unexpected tag element 14874 err = decoder.Decoder.Skip() 14875 if err != nil { 14876 return err 14877 } 14878 14879 } 14880 decoder = originalDecoder 14881 } 14882 *v = sv 14883 return nil 14884} 14885 14886func awsRestxml_deserializeDocumentHealthCheckInUse(v **types.HealthCheckInUse, decoder smithyxml.NodeDecoder) error { 14887 if v == nil { 14888 return fmt.Errorf("unexpected nil of type %T", v) 14889 } 14890 var sv *types.HealthCheckInUse 14891 if *v == nil { 14892 sv = &types.HealthCheckInUse{} 14893 } else { 14894 sv = *v 14895 } 14896 14897 for { 14898 t, done, err := decoder.Token() 14899 if err != nil { 14900 return err 14901 } 14902 if done { 14903 break 14904 } 14905 originalDecoder := decoder 14906 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14907 switch { 14908 case strings.EqualFold("message", t.Name.Local): 14909 val, err := decoder.Value() 14910 if err != nil { 14911 return err 14912 } 14913 if val == nil { 14914 break 14915 } 14916 { 14917 xtv := string(val) 14918 sv.Message = ptr.String(xtv) 14919 } 14920 14921 default: 14922 // Do nothing and ignore the unexpected tag element 14923 err = decoder.Decoder.Skip() 14924 if err != nil { 14925 return err 14926 } 14927 14928 } 14929 decoder = originalDecoder 14930 } 14931 *v = sv 14932 return nil 14933} 14934 14935func awsRestxml_deserializeDocumentHealthCheckObservation(v **types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error { 14936 if v == nil { 14937 return fmt.Errorf("unexpected nil of type %T", v) 14938 } 14939 var sv *types.HealthCheckObservation 14940 if *v == nil { 14941 sv = &types.HealthCheckObservation{} 14942 } else { 14943 sv = *v 14944 } 14945 14946 for { 14947 t, done, err := decoder.Token() 14948 if err != nil { 14949 return err 14950 } 14951 if done { 14952 break 14953 } 14954 originalDecoder := decoder 14955 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14956 switch { 14957 case strings.EqualFold("IPAddress", t.Name.Local): 14958 val, err := decoder.Value() 14959 if err != nil { 14960 return err 14961 } 14962 if val == nil { 14963 break 14964 } 14965 { 14966 xtv := string(val) 14967 sv.IPAddress = ptr.String(xtv) 14968 } 14969 14970 case strings.EqualFold("Region", t.Name.Local): 14971 val, err := decoder.Value() 14972 if err != nil { 14973 return err 14974 } 14975 if val == nil { 14976 break 14977 } 14978 { 14979 xtv := string(val) 14980 sv.Region = types.HealthCheckRegion(xtv) 14981 } 14982 14983 case strings.EqualFold("StatusReport", t.Name.Local): 14984 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14985 if err := awsRestxml_deserializeDocumentStatusReport(&sv.StatusReport, nodeDecoder); err != nil { 14986 return err 14987 } 14988 14989 default: 14990 // Do nothing and ignore the unexpected tag element 14991 err = decoder.Decoder.Skip() 14992 if err != nil { 14993 return err 14994 } 14995 14996 } 14997 decoder = originalDecoder 14998 } 14999 *v = sv 15000 return nil 15001} 15002 15003func awsRestxml_deserializeDocumentHealthCheckObservations(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error { 15004 if v == nil { 15005 return fmt.Errorf("unexpected nil of type %T", v) 15006 } 15007 var sv []types.HealthCheckObservation 15008 if *v == nil { 15009 sv = make([]types.HealthCheckObservation, 0) 15010 } else { 15011 sv = *v 15012 } 15013 15014 originalDecoder := decoder 15015 for { 15016 t, done, err := decoder.Token() 15017 if err != nil { 15018 return err 15019 } 15020 if done { 15021 break 15022 } 15023 switch { 15024 case strings.EqualFold("HealthCheckObservation", t.Name.Local): 15025 var col types.HealthCheckObservation 15026 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15027 destAddr := &col 15028 if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil { 15029 return err 15030 } 15031 col = *destAddr 15032 sv = append(sv, col) 15033 15034 default: 15035 err = decoder.Decoder.Skip() 15036 if err != nil { 15037 return err 15038 } 15039 15040 } 15041 decoder = originalDecoder 15042 } 15043 *v = sv 15044 return nil 15045} 15046 15047func awsRestxml_deserializeDocumentHealthCheckObservationsUnwrapped(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error { 15048 var sv []types.HealthCheckObservation 15049 if *v == nil { 15050 sv = make([]types.HealthCheckObservation, 0) 15051 } else { 15052 sv = *v 15053 } 15054 15055 switch { 15056 default: 15057 var mv types.HealthCheckObservation 15058 t := decoder.StartEl 15059 _ = t 15060 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15061 destAddr := &mv 15062 if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil { 15063 return err 15064 } 15065 mv = *destAddr 15066 sv = append(sv, mv) 15067 } 15068 *v = sv 15069 return nil 15070} 15071func awsRestxml_deserializeDocumentHealthCheckRegionList(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error { 15072 if v == nil { 15073 return fmt.Errorf("unexpected nil of type %T", v) 15074 } 15075 var sv []types.HealthCheckRegion 15076 if *v == nil { 15077 sv = make([]types.HealthCheckRegion, 0) 15078 } else { 15079 sv = *v 15080 } 15081 15082 originalDecoder := decoder 15083 for { 15084 t, done, err := decoder.Token() 15085 if err != nil { 15086 return err 15087 } 15088 if done { 15089 break 15090 } 15091 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15092 decoder = memberDecoder 15093 switch { 15094 case strings.EqualFold("Region", t.Name.Local): 15095 var col types.HealthCheckRegion 15096 val, err := decoder.Value() 15097 if err != nil { 15098 return err 15099 } 15100 if val == nil { 15101 break 15102 } 15103 { 15104 xtv := string(val) 15105 col = types.HealthCheckRegion(xtv) 15106 } 15107 sv = append(sv, col) 15108 15109 default: 15110 err = decoder.Decoder.Skip() 15111 if err != nil { 15112 return err 15113 } 15114 15115 } 15116 decoder = originalDecoder 15117 } 15118 *v = sv 15119 return nil 15120} 15121 15122func awsRestxml_deserializeDocumentHealthCheckRegionListUnwrapped(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error { 15123 var sv []types.HealthCheckRegion 15124 if *v == nil { 15125 sv = make([]types.HealthCheckRegion, 0) 15126 } else { 15127 sv = *v 15128 } 15129 15130 switch { 15131 default: 15132 var mv types.HealthCheckRegion 15133 t := decoder.StartEl 15134 _ = t 15135 val, err := decoder.Value() 15136 if err != nil { 15137 return err 15138 } 15139 if val == nil { 15140 break 15141 } 15142 { 15143 xtv := string(val) 15144 mv = types.HealthCheckRegion(xtv) 15145 } 15146 sv = append(sv, mv) 15147 } 15148 *v = sv 15149 return nil 15150} 15151func awsRestxml_deserializeDocumentHealthChecks(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error { 15152 if v == nil { 15153 return fmt.Errorf("unexpected nil of type %T", v) 15154 } 15155 var sv []types.HealthCheck 15156 if *v == nil { 15157 sv = make([]types.HealthCheck, 0) 15158 } else { 15159 sv = *v 15160 } 15161 15162 originalDecoder := decoder 15163 for { 15164 t, done, err := decoder.Token() 15165 if err != nil { 15166 return err 15167 } 15168 if done { 15169 break 15170 } 15171 switch { 15172 case strings.EqualFold("HealthCheck", t.Name.Local): 15173 var col types.HealthCheck 15174 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15175 destAddr := &col 15176 if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil { 15177 return err 15178 } 15179 col = *destAddr 15180 sv = append(sv, col) 15181 15182 default: 15183 err = decoder.Decoder.Skip() 15184 if err != nil { 15185 return err 15186 } 15187 15188 } 15189 decoder = originalDecoder 15190 } 15191 *v = sv 15192 return nil 15193} 15194 15195func awsRestxml_deserializeDocumentHealthChecksUnwrapped(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error { 15196 var sv []types.HealthCheck 15197 if *v == nil { 15198 sv = make([]types.HealthCheck, 0) 15199 } else { 15200 sv = *v 15201 } 15202 15203 switch { 15204 default: 15205 var mv types.HealthCheck 15206 t := decoder.StartEl 15207 _ = t 15208 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15209 destAddr := &mv 15210 if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil { 15211 return err 15212 } 15213 mv = *destAddr 15214 sv = append(sv, mv) 15215 } 15216 *v = sv 15217 return nil 15218} 15219func awsRestxml_deserializeDocumentHealthCheckVersionMismatch(v **types.HealthCheckVersionMismatch, decoder smithyxml.NodeDecoder) error { 15220 if v == nil { 15221 return fmt.Errorf("unexpected nil of type %T", v) 15222 } 15223 var sv *types.HealthCheckVersionMismatch 15224 if *v == nil { 15225 sv = &types.HealthCheckVersionMismatch{} 15226 } else { 15227 sv = *v 15228 } 15229 15230 for { 15231 t, done, err := decoder.Token() 15232 if err != nil { 15233 return err 15234 } 15235 if done { 15236 break 15237 } 15238 originalDecoder := decoder 15239 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15240 switch { 15241 case strings.EqualFold("message", t.Name.Local): 15242 val, err := decoder.Value() 15243 if err != nil { 15244 return err 15245 } 15246 if val == nil { 15247 break 15248 } 15249 { 15250 xtv := string(val) 15251 sv.Message = ptr.String(xtv) 15252 } 15253 15254 default: 15255 // Do nothing and ignore the unexpected tag element 15256 err = decoder.Decoder.Skip() 15257 if err != nil { 15258 return err 15259 } 15260 15261 } 15262 decoder = originalDecoder 15263 } 15264 *v = sv 15265 return nil 15266} 15267 15268func awsRestxml_deserializeDocumentHostedZone(v **types.HostedZone, decoder smithyxml.NodeDecoder) error { 15269 if v == nil { 15270 return fmt.Errorf("unexpected nil of type %T", v) 15271 } 15272 var sv *types.HostedZone 15273 if *v == nil { 15274 sv = &types.HostedZone{} 15275 } else { 15276 sv = *v 15277 } 15278 15279 for { 15280 t, done, err := decoder.Token() 15281 if err != nil { 15282 return err 15283 } 15284 if done { 15285 break 15286 } 15287 originalDecoder := decoder 15288 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15289 switch { 15290 case strings.EqualFold("CallerReference", t.Name.Local): 15291 val, err := decoder.Value() 15292 if err != nil { 15293 return err 15294 } 15295 if val == nil { 15296 break 15297 } 15298 { 15299 xtv := string(val) 15300 sv.CallerReference = ptr.String(xtv) 15301 } 15302 15303 case strings.EqualFold("Config", t.Name.Local): 15304 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15305 if err := awsRestxml_deserializeDocumentHostedZoneConfig(&sv.Config, nodeDecoder); err != nil { 15306 return err 15307 } 15308 15309 case strings.EqualFold("Id", t.Name.Local): 15310 val, err := decoder.Value() 15311 if err != nil { 15312 return err 15313 } 15314 if val == nil { 15315 break 15316 } 15317 { 15318 xtv := string(val) 15319 sv.Id = ptr.String(xtv) 15320 } 15321 15322 case strings.EqualFold("LinkedService", t.Name.Local): 15323 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15324 if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil { 15325 return err 15326 } 15327 15328 case strings.EqualFold("Name", t.Name.Local): 15329 val, err := decoder.Value() 15330 if err != nil { 15331 return err 15332 } 15333 if val == nil { 15334 break 15335 } 15336 { 15337 xtv := string(val) 15338 sv.Name = ptr.String(xtv) 15339 } 15340 15341 case strings.EqualFold("ResourceRecordSetCount", t.Name.Local): 15342 val, err := decoder.Value() 15343 if err != nil { 15344 return err 15345 } 15346 if val == nil { 15347 break 15348 } 15349 { 15350 xtv := string(val) 15351 i64, err := strconv.ParseInt(xtv, 10, 64) 15352 if err != nil { 15353 return err 15354 } 15355 sv.ResourceRecordSetCount = ptr.Int64(i64) 15356 } 15357 15358 default: 15359 // Do nothing and ignore the unexpected tag element 15360 err = decoder.Decoder.Skip() 15361 if err != nil { 15362 return err 15363 } 15364 15365 } 15366 decoder = originalDecoder 15367 } 15368 *v = sv 15369 return nil 15370} 15371 15372func awsRestxml_deserializeDocumentHostedZoneAlreadyExists(v **types.HostedZoneAlreadyExists, decoder smithyxml.NodeDecoder) error { 15373 if v == nil { 15374 return fmt.Errorf("unexpected nil of type %T", v) 15375 } 15376 var sv *types.HostedZoneAlreadyExists 15377 if *v == nil { 15378 sv = &types.HostedZoneAlreadyExists{} 15379 } else { 15380 sv = *v 15381 } 15382 15383 for { 15384 t, done, err := decoder.Token() 15385 if err != nil { 15386 return err 15387 } 15388 if done { 15389 break 15390 } 15391 originalDecoder := decoder 15392 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15393 switch { 15394 case strings.EqualFold("message", t.Name.Local): 15395 val, err := decoder.Value() 15396 if err != nil { 15397 return err 15398 } 15399 if val == nil { 15400 break 15401 } 15402 { 15403 xtv := string(val) 15404 sv.Message = ptr.String(xtv) 15405 } 15406 15407 default: 15408 // Do nothing and ignore the unexpected tag element 15409 err = decoder.Decoder.Skip() 15410 if err != nil { 15411 return err 15412 } 15413 15414 } 15415 decoder = originalDecoder 15416 } 15417 *v = sv 15418 return nil 15419} 15420 15421func awsRestxml_deserializeDocumentHostedZoneConfig(v **types.HostedZoneConfig, decoder smithyxml.NodeDecoder) error { 15422 if v == nil { 15423 return fmt.Errorf("unexpected nil of type %T", v) 15424 } 15425 var sv *types.HostedZoneConfig 15426 if *v == nil { 15427 sv = &types.HostedZoneConfig{} 15428 } else { 15429 sv = *v 15430 } 15431 15432 for { 15433 t, done, err := decoder.Token() 15434 if err != nil { 15435 return err 15436 } 15437 if done { 15438 break 15439 } 15440 originalDecoder := decoder 15441 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15442 switch { 15443 case strings.EqualFold("Comment", t.Name.Local): 15444 val, err := decoder.Value() 15445 if err != nil { 15446 return err 15447 } 15448 if val == nil { 15449 break 15450 } 15451 { 15452 xtv := string(val) 15453 sv.Comment = ptr.String(xtv) 15454 } 15455 15456 case strings.EqualFold("PrivateZone", t.Name.Local): 15457 val, err := decoder.Value() 15458 if err != nil { 15459 return err 15460 } 15461 if val == nil { 15462 break 15463 } 15464 { 15465 xtv, err := strconv.ParseBool(string(val)) 15466 if err != nil { 15467 return fmt.Errorf("expected IsPrivateZone to be of type *bool, got %T instead", val) 15468 } 15469 sv.PrivateZone = xtv 15470 } 15471 15472 default: 15473 // Do nothing and ignore the unexpected tag element 15474 err = decoder.Decoder.Skip() 15475 if err != nil { 15476 return err 15477 } 15478 15479 } 15480 decoder = originalDecoder 15481 } 15482 *v = sv 15483 return nil 15484} 15485 15486func awsRestxml_deserializeDocumentHostedZoneLimit(v **types.HostedZoneLimit, decoder smithyxml.NodeDecoder) error { 15487 if v == nil { 15488 return fmt.Errorf("unexpected nil of type %T", v) 15489 } 15490 var sv *types.HostedZoneLimit 15491 if *v == nil { 15492 sv = &types.HostedZoneLimit{} 15493 } else { 15494 sv = *v 15495 } 15496 15497 for { 15498 t, done, err := decoder.Token() 15499 if err != nil { 15500 return err 15501 } 15502 if done { 15503 break 15504 } 15505 originalDecoder := decoder 15506 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15507 switch { 15508 case strings.EqualFold("Type", t.Name.Local): 15509 val, err := decoder.Value() 15510 if err != nil { 15511 return err 15512 } 15513 if val == nil { 15514 break 15515 } 15516 { 15517 xtv := string(val) 15518 sv.Type = types.HostedZoneLimitType(xtv) 15519 } 15520 15521 case strings.EqualFold("Value", t.Name.Local): 15522 val, err := decoder.Value() 15523 if err != nil { 15524 return err 15525 } 15526 if val == nil { 15527 break 15528 } 15529 { 15530 xtv := string(val) 15531 i64, err := strconv.ParseInt(xtv, 10, 64) 15532 if err != nil { 15533 return err 15534 } 15535 sv.Value = i64 15536 } 15537 15538 default: 15539 // Do nothing and ignore the unexpected tag element 15540 err = decoder.Decoder.Skip() 15541 if err != nil { 15542 return err 15543 } 15544 15545 } 15546 decoder = originalDecoder 15547 } 15548 *v = sv 15549 return nil 15550} 15551 15552func awsRestxml_deserializeDocumentHostedZoneNotEmpty(v **types.HostedZoneNotEmpty, decoder smithyxml.NodeDecoder) error { 15553 if v == nil { 15554 return fmt.Errorf("unexpected nil of type %T", v) 15555 } 15556 var sv *types.HostedZoneNotEmpty 15557 if *v == nil { 15558 sv = &types.HostedZoneNotEmpty{} 15559 } else { 15560 sv = *v 15561 } 15562 15563 for { 15564 t, done, err := decoder.Token() 15565 if err != nil { 15566 return err 15567 } 15568 if done { 15569 break 15570 } 15571 originalDecoder := decoder 15572 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15573 switch { 15574 case strings.EqualFold("message", t.Name.Local): 15575 val, err := decoder.Value() 15576 if err != nil { 15577 return err 15578 } 15579 if val == nil { 15580 break 15581 } 15582 { 15583 xtv := string(val) 15584 sv.Message = ptr.String(xtv) 15585 } 15586 15587 default: 15588 // Do nothing and ignore the unexpected tag element 15589 err = decoder.Decoder.Skip() 15590 if err != nil { 15591 return err 15592 } 15593 15594 } 15595 decoder = originalDecoder 15596 } 15597 *v = sv 15598 return nil 15599} 15600 15601func awsRestxml_deserializeDocumentHostedZoneNotFound(v **types.HostedZoneNotFound, decoder smithyxml.NodeDecoder) error { 15602 if v == nil { 15603 return fmt.Errorf("unexpected nil of type %T", v) 15604 } 15605 var sv *types.HostedZoneNotFound 15606 if *v == nil { 15607 sv = &types.HostedZoneNotFound{} 15608 } else { 15609 sv = *v 15610 } 15611 15612 for { 15613 t, done, err := decoder.Token() 15614 if err != nil { 15615 return err 15616 } 15617 if done { 15618 break 15619 } 15620 originalDecoder := decoder 15621 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15622 switch { 15623 case strings.EqualFold("message", t.Name.Local): 15624 val, err := decoder.Value() 15625 if err != nil { 15626 return err 15627 } 15628 if val == nil { 15629 break 15630 } 15631 { 15632 xtv := string(val) 15633 sv.Message = ptr.String(xtv) 15634 } 15635 15636 default: 15637 // Do nothing and ignore the unexpected tag element 15638 err = decoder.Decoder.Skip() 15639 if err != nil { 15640 return err 15641 } 15642 15643 } 15644 decoder = originalDecoder 15645 } 15646 *v = sv 15647 return nil 15648} 15649 15650func awsRestxml_deserializeDocumentHostedZoneNotPrivate(v **types.HostedZoneNotPrivate, decoder smithyxml.NodeDecoder) error { 15651 if v == nil { 15652 return fmt.Errorf("unexpected nil of type %T", v) 15653 } 15654 var sv *types.HostedZoneNotPrivate 15655 if *v == nil { 15656 sv = &types.HostedZoneNotPrivate{} 15657 } else { 15658 sv = *v 15659 } 15660 15661 for { 15662 t, done, err := decoder.Token() 15663 if err != nil { 15664 return err 15665 } 15666 if done { 15667 break 15668 } 15669 originalDecoder := decoder 15670 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15671 switch { 15672 case strings.EqualFold("message", t.Name.Local): 15673 val, err := decoder.Value() 15674 if err != nil { 15675 return err 15676 } 15677 if val == nil { 15678 break 15679 } 15680 { 15681 xtv := string(val) 15682 sv.Message = ptr.String(xtv) 15683 } 15684 15685 default: 15686 // Do nothing and ignore the unexpected tag element 15687 err = decoder.Decoder.Skip() 15688 if err != nil { 15689 return err 15690 } 15691 15692 } 15693 decoder = originalDecoder 15694 } 15695 *v = sv 15696 return nil 15697} 15698 15699func awsRestxml_deserializeDocumentHostedZoneOwner(v **types.HostedZoneOwner, decoder smithyxml.NodeDecoder) error { 15700 if v == nil { 15701 return fmt.Errorf("unexpected nil of type %T", v) 15702 } 15703 var sv *types.HostedZoneOwner 15704 if *v == nil { 15705 sv = &types.HostedZoneOwner{} 15706 } else { 15707 sv = *v 15708 } 15709 15710 for { 15711 t, done, err := decoder.Token() 15712 if err != nil { 15713 return err 15714 } 15715 if done { 15716 break 15717 } 15718 originalDecoder := decoder 15719 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15720 switch { 15721 case strings.EqualFold("OwningAccount", t.Name.Local): 15722 val, err := decoder.Value() 15723 if err != nil { 15724 return err 15725 } 15726 if val == nil { 15727 break 15728 } 15729 { 15730 xtv := string(val) 15731 sv.OwningAccount = ptr.String(xtv) 15732 } 15733 15734 case strings.EqualFold("OwningService", t.Name.Local): 15735 val, err := decoder.Value() 15736 if err != nil { 15737 return err 15738 } 15739 if val == nil { 15740 break 15741 } 15742 { 15743 xtv := string(val) 15744 sv.OwningService = ptr.String(xtv) 15745 } 15746 15747 default: 15748 // Do nothing and ignore the unexpected tag element 15749 err = decoder.Decoder.Skip() 15750 if err != nil { 15751 return err 15752 } 15753 15754 } 15755 decoder = originalDecoder 15756 } 15757 *v = sv 15758 return nil 15759} 15760 15761func awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(v **types.HostedZonePartiallyDelegated, decoder smithyxml.NodeDecoder) error { 15762 if v == nil { 15763 return fmt.Errorf("unexpected nil of type %T", v) 15764 } 15765 var sv *types.HostedZonePartiallyDelegated 15766 if *v == nil { 15767 sv = &types.HostedZonePartiallyDelegated{} 15768 } else { 15769 sv = *v 15770 } 15771 15772 for { 15773 t, done, err := decoder.Token() 15774 if err != nil { 15775 return err 15776 } 15777 if done { 15778 break 15779 } 15780 originalDecoder := decoder 15781 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15782 switch { 15783 case strings.EqualFold("message", t.Name.Local): 15784 val, err := decoder.Value() 15785 if err != nil { 15786 return err 15787 } 15788 if val == nil { 15789 break 15790 } 15791 { 15792 xtv := string(val) 15793 sv.Message = ptr.String(xtv) 15794 } 15795 15796 default: 15797 // Do nothing and ignore the unexpected tag element 15798 err = decoder.Decoder.Skip() 15799 if err != nil { 15800 return err 15801 } 15802 15803 } 15804 decoder = originalDecoder 15805 } 15806 *v = sv 15807 return nil 15808} 15809 15810func awsRestxml_deserializeDocumentHostedZones(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error { 15811 if v == nil { 15812 return fmt.Errorf("unexpected nil of type %T", v) 15813 } 15814 var sv []types.HostedZone 15815 if *v == nil { 15816 sv = make([]types.HostedZone, 0) 15817 } else { 15818 sv = *v 15819 } 15820 15821 originalDecoder := decoder 15822 for { 15823 t, done, err := decoder.Token() 15824 if err != nil { 15825 return err 15826 } 15827 if done { 15828 break 15829 } 15830 switch { 15831 case strings.EqualFold("HostedZone", t.Name.Local): 15832 var col types.HostedZone 15833 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15834 destAddr := &col 15835 if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil { 15836 return err 15837 } 15838 col = *destAddr 15839 sv = append(sv, col) 15840 15841 default: 15842 err = decoder.Decoder.Skip() 15843 if err != nil { 15844 return err 15845 } 15846 15847 } 15848 decoder = originalDecoder 15849 } 15850 *v = sv 15851 return nil 15852} 15853 15854func awsRestxml_deserializeDocumentHostedZonesUnwrapped(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error { 15855 var sv []types.HostedZone 15856 if *v == nil { 15857 sv = make([]types.HostedZone, 0) 15858 } else { 15859 sv = *v 15860 } 15861 15862 switch { 15863 default: 15864 var mv types.HostedZone 15865 t := decoder.StartEl 15866 _ = t 15867 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15868 destAddr := &mv 15869 if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil { 15870 return err 15871 } 15872 mv = *destAddr 15873 sv = append(sv, mv) 15874 } 15875 *v = sv 15876 return nil 15877} 15878func awsRestxml_deserializeDocumentHostedZoneSummaries(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error { 15879 if v == nil { 15880 return fmt.Errorf("unexpected nil of type %T", v) 15881 } 15882 var sv []types.HostedZoneSummary 15883 if *v == nil { 15884 sv = make([]types.HostedZoneSummary, 0) 15885 } else { 15886 sv = *v 15887 } 15888 15889 originalDecoder := decoder 15890 for { 15891 t, done, err := decoder.Token() 15892 if err != nil { 15893 return err 15894 } 15895 if done { 15896 break 15897 } 15898 switch { 15899 case strings.EqualFold("HostedZoneSummary", t.Name.Local): 15900 var col types.HostedZoneSummary 15901 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15902 destAddr := &col 15903 if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil { 15904 return err 15905 } 15906 col = *destAddr 15907 sv = append(sv, col) 15908 15909 default: 15910 err = decoder.Decoder.Skip() 15911 if err != nil { 15912 return err 15913 } 15914 15915 } 15916 decoder = originalDecoder 15917 } 15918 *v = sv 15919 return nil 15920} 15921 15922func awsRestxml_deserializeDocumentHostedZoneSummariesUnwrapped(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error { 15923 var sv []types.HostedZoneSummary 15924 if *v == nil { 15925 sv = make([]types.HostedZoneSummary, 0) 15926 } else { 15927 sv = *v 15928 } 15929 15930 switch { 15931 default: 15932 var mv types.HostedZoneSummary 15933 t := decoder.StartEl 15934 _ = t 15935 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15936 destAddr := &mv 15937 if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil { 15938 return err 15939 } 15940 mv = *destAddr 15941 sv = append(sv, mv) 15942 } 15943 *v = sv 15944 return nil 15945} 15946func awsRestxml_deserializeDocumentHostedZoneSummary(v **types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error { 15947 if v == nil { 15948 return fmt.Errorf("unexpected nil of type %T", v) 15949 } 15950 var sv *types.HostedZoneSummary 15951 if *v == nil { 15952 sv = &types.HostedZoneSummary{} 15953 } else { 15954 sv = *v 15955 } 15956 15957 for { 15958 t, done, err := decoder.Token() 15959 if err != nil { 15960 return err 15961 } 15962 if done { 15963 break 15964 } 15965 originalDecoder := decoder 15966 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15967 switch { 15968 case strings.EqualFold("HostedZoneId", t.Name.Local): 15969 val, err := decoder.Value() 15970 if err != nil { 15971 return err 15972 } 15973 if val == nil { 15974 break 15975 } 15976 { 15977 xtv := string(val) 15978 sv.HostedZoneId = ptr.String(xtv) 15979 } 15980 15981 case strings.EqualFold("Name", t.Name.Local): 15982 val, err := decoder.Value() 15983 if err != nil { 15984 return err 15985 } 15986 if val == nil { 15987 break 15988 } 15989 { 15990 xtv := string(val) 15991 sv.Name = ptr.String(xtv) 15992 } 15993 15994 case strings.EqualFold("Owner", t.Name.Local): 15995 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15996 if err := awsRestxml_deserializeDocumentHostedZoneOwner(&sv.Owner, nodeDecoder); err != nil { 15997 return err 15998 } 15999 16000 default: 16001 // Do nothing and ignore the unexpected tag element 16002 err = decoder.Decoder.Skip() 16003 if err != nil { 16004 return err 16005 } 16006 16007 } 16008 decoder = originalDecoder 16009 } 16010 *v = sv 16011 return nil 16012} 16013 16014func awsRestxml_deserializeDocumentIncompatibleVersion(v **types.IncompatibleVersion, decoder smithyxml.NodeDecoder) error { 16015 if v == nil { 16016 return fmt.Errorf("unexpected nil of type %T", v) 16017 } 16018 var sv *types.IncompatibleVersion 16019 if *v == nil { 16020 sv = &types.IncompatibleVersion{} 16021 } else { 16022 sv = *v 16023 } 16024 16025 for { 16026 t, done, err := decoder.Token() 16027 if err != nil { 16028 return err 16029 } 16030 if done { 16031 break 16032 } 16033 originalDecoder := decoder 16034 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16035 switch { 16036 case strings.EqualFold("message", t.Name.Local): 16037 val, err := decoder.Value() 16038 if err != nil { 16039 return err 16040 } 16041 if val == nil { 16042 break 16043 } 16044 { 16045 xtv := string(val) 16046 sv.Message = ptr.String(xtv) 16047 } 16048 16049 default: 16050 // Do nothing and ignore the unexpected tag element 16051 err = decoder.Decoder.Skip() 16052 if err != nil { 16053 return err 16054 } 16055 16056 } 16057 decoder = originalDecoder 16058 } 16059 *v = sv 16060 return nil 16061} 16062 16063func awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(v **types.InsufficientCloudWatchLogsResourcePolicy, decoder smithyxml.NodeDecoder) error { 16064 if v == nil { 16065 return fmt.Errorf("unexpected nil of type %T", v) 16066 } 16067 var sv *types.InsufficientCloudWatchLogsResourcePolicy 16068 if *v == nil { 16069 sv = &types.InsufficientCloudWatchLogsResourcePolicy{} 16070 } else { 16071 sv = *v 16072 } 16073 16074 for { 16075 t, done, err := decoder.Token() 16076 if err != nil { 16077 return err 16078 } 16079 if done { 16080 break 16081 } 16082 originalDecoder := decoder 16083 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16084 switch { 16085 case strings.EqualFold("message", t.Name.Local): 16086 val, err := decoder.Value() 16087 if err != nil { 16088 return err 16089 } 16090 if val == nil { 16091 break 16092 } 16093 { 16094 xtv := string(val) 16095 sv.Message = ptr.String(xtv) 16096 } 16097 16098 default: 16099 // Do nothing and ignore the unexpected tag element 16100 err = decoder.Decoder.Skip() 16101 if err != nil { 16102 return err 16103 } 16104 16105 } 16106 decoder = originalDecoder 16107 } 16108 *v = sv 16109 return nil 16110} 16111 16112func awsRestxml_deserializeDocumentInvalidArgument(v **types.InvalidArgument, decoder smithyxml.NodeDecoder) error { 16113 if v == nil { 16114 return fmt.Errorf("unexpected nil of type %T", v) 16115 } 16116 var sv *types.InvalidArgument 16117 if *v == nil { 16118 sv = &types.InvalidArgument{} 16119 } else { 16120 sv = *v 16121 } 16122 16123 for { 16124 t, done, err := decoder.Token() 16125 if err != nil { 16126 return err 16127 } 16128 if done { 16129 break 16130 } 16131 originalDecoder := decoder 16132 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16133 switch { 16134 case strings.EqualFold("message", t.Name.Local): 16135 val, err := decoder.Value() 16136 if err != nil { 16137 return err 16138 } 16139 if val == nil { 16140 break 16141 } 16142 { 16143 xtv := string(val) 16144 sv.Message = ptr.String(xtv) 16145 } 16146 16147 default: 16148 // Do nothing and ignore the unexpected tag element 16149 err = decoder.Decoder.Skip() 16150 if err != nil { 16151 return err 16152 } 16153 16154 } 16155 decoder = originalDecoder 16156 } 16157 *v = sv 16158 return nil 16159} 16160 16161func awsRestxml_deserializeDocumentInvalidChangeBatch(v **types.InvalidChangeBatch, decoder smithyxml.NodeDecoder) error { 16162 if v == nil { 16163 return fmt.Errorf("unexpected nil of type %T", v) 16164 } 16165 var sv *types.InvalidChangeBatch 16166 if *v == nil { 16167 sv = &types.InvalidChangeBatch{} 16168 } else { 16169 sv = *v 16170 } 16171 16172 for { 16173 t, done, err := decoder.Token() 16174 if err != nil { 16175 return err 16176 } 16177 if done { 16178 break 16179 } 16180 originalDecoder := decoder 16181 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16182 switch { 16183 case strings.EqualFold("message", t.Name.Local): 16184 val, err := decoder.Value() 16185 if err != nil { 16186 return err 16187 } 16188 if val == nil { 16189 break 16190 } 16191 { 16192 xtv := string(val) 16193 sv.Message = ptr.String(xtv) 16194 } 16195 16196 case strings.EqualFold("messages", t.Name.Local): 16197 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16198 if err := awsRestxml_deserializeDocumentErrorMessages(&sv.Messages, nodeDecoder); err != nil { 16199 return err 16200 } 16201 16202 default: 16203 // Do nothing and ignore the unexpected tag element 16204 err = decoder.Decoder.Skip() 16205 if err != nil { 16206 return err 16207 } 16208 16209 } 16210 decoder = originalDecoder 16211 } 16212 *v = sv 16213 return nil 16214} 16215 16216func awsRestxml_deserializeDocumentInvalidDomainName(v **types.InvalidDomainName, decoder smithyxml.NodeDecoder) error { 16217 if v == nil { 16218 return fmt.Errorf("unexpected nil of type %T", v) 16219 } 16220 var sv *types.InvalidDomainName 16221 if *v == nil { 16222 sv = &types.InvalidDomainName{} 16223 } else { 16224 sv = *v 16225 } 16226 16227 for { 16228 t, done, err := decoder.Token() 16229 if err != nil { 16230 return err 16231 } 16232 if done { 16233 break 16234 } 16235 originalDecoder := decoder 16236 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16237 switch { 16238 case strings.EqualFold("message", t.Name.Local): 16239 val, err := decoder.Value() 16240 if err != nil { 16241 return err 16242 } 16243 if val == nil { 16244 break 16245 } 16246 { 16247 xtv := string(val) 16248 sv.Message = ptr.String(xtv) 16249 } 16250 16251 default: 16252 // Do nothing and ignore the unexpected tag element 16253 err = decoder.Decoder.Skip() 16254 if err != nil { 16255 return err 16256 } 16257 16258 } 16259 decoder = originalDecoder 16260 } 16261 *v = sv 16262 return nil 16263} 16264 16265func awsRestxml_deserializeDocumentInvalidInput(v **types.InvalidInput, decoder smithyxml.NodeDecoder) error { 16266 if v == nil { 16267 return fmt.Errorf("unexpected nil of type %T", v) 16268 } 16269 var sv *types.InvalidInput 16270 if *v == nil { 16271 sv = &types.InvalidInput{} 16272 } else { 16273 sv = *v 16274 } 16275 16276 for { 16277 t, done, err := decoder.Token() 16278 if err != nil { 16279 return err 16280 } 16281 if done { 16282 break 16283 } 16284 originalDecoder := decoder 16285 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16286 switch { 16287 case strings.EqualFold("message", t.Name.Local): 16288 val, err := decoder.Value() 16289 if err != nil { 16290 return err 16291 } 16292 if val == nil { 16293 break 16294 } 16295 { 16296 xtv := string(val) 16297 sv.Message = ptr.String(xtv) 16298 } 16299 16300 default: 16301 // Do nothing and ignore the unexpected tag element 16302 err = decoder.Decoder.Skip() 16303 if err != nil { 16304 return err 16305 } 16306 16307 } 16308 decoder = originalDecoder 16309 } 16310 *v = sv 16311 return nil 16312} 16313 16314func awsRestxml_deserializeDocumentInvalidKeySigningKeyName(v **types.InvalidKeySigningKeyName, decoder smithyxml.NodeDecoder) error { 16315 if v == nil { 16316 return fmt.Errorf("unexpected nil of type %T", v) 16317 } 16318 var sv *types.InvalidKeySigningKeyName 16319 if *v == nil { 16320 sv = &types.InvalidKeySigningKeyName{} 16321 } else { 16322 sv = *v 16323 } 16324 16325 for { 16326 t, done, err := decoder.Token() 16327 if err != nil { 16328 return err 16329 } 16330 if done { 16331 break 16332 } 16333 originalDecoder := decoder 16334 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16335 switch { 16336 case strings.EqualFold("message", t.Name.Local): 16337 val, err := decoder.Value() 16338 if err != nil { 16339 return err 16340 } 16341 if val == nil { 16342 break 16343 } 16344 { 16345 xtv := string(val) 16346 sv.Message = ptr.String(xtv) 16347 } 16348 16349 default: 16350 // Do nothing and ignore the unexpected tag element 16351 err = decoder.Decoder.Skip() 16352 if err != nil { 16353 return err 16354 } 16355 16356 } 16357 decoder = originalDecoder 16358 } 16359 *v = sv 16360 return nil 16361} 16362 16363func awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(v **types.InvalidKeySigningKeyStatus, decoder smithyxml.NodeDecoder) error { 16364 if v == nil { 16365 return fmt.Errorf("unexpected nil of type %T", v) 16366 } 16367 var sv *types.InvalidKeySigningKeyStatus 16368 if *v == nil { 16369 sv = &types.InvalidKeySigningKeyStatus{} 16370 } else { 16371 sv = *v 16372 } 16373 16374 for { 16375 t, done, err := decoder.Token() 16376 if err != nil { 16377 return err 16378 } 16379 if done { 16380 break 16381 } 16382 originalDecoder := decoder 16383 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16384 switch { 16385 case strings.EqualFold("message", t.Name.Local): 16386 val, err := decoder.Value() 16387 if err != nil { 16388 return err 16389 } 16390 if val == nil { 16391 break 16392 } 16393 { 16394 xtv := string(val) 16395 sv.Message = ptr.String(xtv) 16396 } 16397 16398 default: 16399 // Do nothing and ignore the unexpected tag element 16400 err = decoder.Decoder.Skip() 16401 if err != nil { 16402 return err 16403 } 16404 16405 } 16406 decoder = originalDecoder 16407 } 16408 *v = sv 16409 return nil 16410} 16411 16412func awsRestxml_deserializeDocumentInvalidKMSArn(v **types.InvalidKMSArn, decoder smithyxml.NodeDecoder) error { 16413 if v == nil { 16414 return fmt.Errorf("unexpected nil of type %T", v) 16415 } 16416 var sv *types.InvalidKMSArn 16417 if *v == nil { 16418 sv = &types.InvalidKMSArn{} 16419 } else { 16420 sv = *v 16421 } 16422 16423 for { 16424 t, done, err := decoder.Token() 16425 if err != nil { 16426 return err 16427 } 16428 if done { 16429 break 16430 } 16431 originalDecoder := decoder 16432 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16433 switch { 16434 case strings.EqualFold("message", t.Name.Local): 16435 val, err := decoder.Value() 16436 if err != nil { 16437 return err 16438 } 16439 if val == nil { 16440 break 16441 } 16442 { 16443 xtv := string(val) 16444 sv.Message = ptr.String(xtv) 16445 } 16446 16447 default: 16448 // Do nothing and ignore the unexpected tag element 16449 err = decoder.Decoder.Skip() 16450 if err != nil { 16451 return err 16452 } 16453 16454 } 16455 decoder = originalDecoder 16456 } 16457 *v = sv 16458 return nil 16459} 16460 16461func awsRestxml_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, decoder smithyxml.NodeDecoder) error { 16462 if v == nil { 16463 return fmt.Errorf("unexpected nil of type %T", v) 16464 } 16465 var sv *types.InvalidPaginationToken 16466 if *v == nil { 16467 sv = &types.InvalidPaginationToken{} 16468 } else { 16469 sv = *v 16470 } 16471 16472 for { 16473 t, done, err := decoder.Token() 16474 if err != nil { 16475 return err 16476 } 16477 if done { 16478 break 16479 } 16480 originalDecoder := decoder 16481 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16482 switch { 16483 case strings.EqualFold("message", t.Name.Local): 16484 val, err := decoder.Value() 16485 if err != nil { 16486 return err 16487 } 16488 if val == nil { 16489 break 16490 } 16491 { 16492 xtv := string(val) 16493 sv.Message = ptr.String(xtv) 16494 } 16495 16496 default: 16497 // Do nothing and ignore the unexpected tag element 16498 err = decoder.Decoder.Skip() 16499 if err != nil { 16500 return err 16501 } 16502 16503 } 16504 decoder = originalDecoder 16505 } 16506 *v = sv 16507 return nil 16508} 16509 16510func awsRestxml_deserializeDocumentInvalidSigningStatus(v **types.InvalidSigningStatus, decoder smithyxml.NodeDecoder) error { 16511 if v == nil { 16512 return fmt.Errorf("unexpected nil of type %T", v) 16513 } 16514 var sv *types.InvalidSigningStatus 16515 if *v == nil { 16516 sv = &types.InvalidSigningStatus{} 16517 } else { 16518 sv = *v 16519 } 16520 16521 for { 16522 t, done, err := decoder.Token() 16523 if err != nil { 16524 return err 16525 } 16526 if done { 16527 break 16528 } 16529 originalDecoder := decoder 16530 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16531 switch { 16532 case strings.EqualFold("message", t.Name.Local): 16533 val, err := decoder.Value() 16534 if err != nil { 16535 return err 16536 } 16537 if val == nil { 16538 break 16539 } 16540 { 16541 xtv := string(val) 16542 sv.Message = ptr.String(xtv) 16543 } 16544 16545 default: 16546 // Do nothing and ignore the unexpected tag element 16547 err = decoder.Decoder.Skip() 16548 if err != nil { 16549 return err 16550 } 16551 16552 } 16553 decoder = originalDecoder 16554 } 16555 *v = sv 16556 return nil 16557} 16558 16559func awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(v **types.InvalidTrafficPolicyDocument, decoder smithyxml.NodeDecoder) error { 16560 if v == nil { 16561 return fmt.Errorf("unexpected nil of type %T", v) 16562 } 16563 var sv *types.InvalidTrafficPolicyDocument 16564 if *v == nil { 16565 sv = &types.InvalidTrafficPolicyDocument{} 16566 } else { 16567 sv = *v 16568 } 16569 16570 for { 16571 t, done, err := decoder.Token() 16572 if err != nil { 16573 return err 16574 } 16575 if done { 16576 break 16577 } 16578 originalDecoder := decoder 16579 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16580 switch { 16581 case strings.EqualFold("message", t.Name.Local): 16582 val, err := decoder.Value() 16583 if err != nil { 16584 return err 16585 } 16586 if val == nil { 16587 break 16588 } 16589 { 16590 xtv := string(val) 16591 sv.Message = ptr.String(xtv) 16592 } 16593 16594 default: 16595 // Do nothing and ignore the unexpected tag element 16596 err = decoder.Decoder.Skip() 16597 if err != nil { 16598 return err 16599 } 16600 16601 } 16602 decoder = originalDecoder 16603 } 16604 *v = sv 16605 return nil 16606} 16607 16608func awsRestxml_deserializeDocumentInvalidVPCId(v **types.InvalidVPCId, decoder smithyxml.NodeDecoder) error { 16609 if v == nil { 16610 return fmt.Errorf("unexpected nil of type %T", v) 16611 } 16612 var sv *types.InvalidVPCId 16613 if *v == nil { 16614 sv = &types.InvalidVPCId{} 16615 } else { 16616 sv = *v 16617 } 16618 16619 for { 16620 t, done, err := decoder.Token() 16621 if err != nil { 16622 return err 16623 } 16624 if done { 16625 break 16626 } 16627 originalDecoder := decoder 16628 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16629 switch { 16630 case strings.EqualFold("message", t.Name.Local): 16631 val, err := decoder.Value() 16632 if err != nil { 16633 return err 16634 } 16635 if val == nil { 16636 break 16637 } 16638 { 16639 xtv := string(val) 16640 sv.Message = ptr.String(xtv) 16641 } 16642 16643 default: 16644 // Do nothing and ignore the unexpected tag element 16645 err = decoder.Decoder.Skip() 16646 if err != nil { 16647 return err 16648 } 16649 16650 } 16651 decoder = originalDecoder 16652 } 16653 *v = sv 16654 return nil 16655} 16656 16657func awsRestxml_deserializeDocumentKeySigningKey(v **types.KeySigningKey, decoder smithyxml.NodeDecoder) error { 16658 if v == nil { 16659 return fmt.Errorf("unexpected nil of type %T", v) 16660 } 16661 var sv *types.KeySigningKey 16662 if *v == nil { 16663 sv = &types.KeySigningKey{} 16664 } else { 16665 sv = *v 16666 } 16667 16668 for { 16669 t, done, err := decoder.Token() 16670 if err != nil { 16671 return err 16672 } 16673 if done { 16674 break 16675 } 16676 originalDecoder := decoder 16677 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16678 switch { 16679 case strings.EqualFold("CreatedDate", t.Name.Local): 16680 val, err := decoder.Value() 16681 if err != nil { 16682 return err 16683 } 16684 if val == nil { 16685 break 16686 } 16687 { 16688 xtv := string(val) 16689 t, err := smithytime.ParseDateTime(xtv) 16690 if err != nil { 16691 return err 16692 } 16693 sv.CreatedDate = ptr.Time(t) 16694 } 16695 16696 case strings.EqualFold("DigestAlgorithmMnemonic", t.Name.Local): 16697 val, err := decoder.Value() 16698 if err != nil { 16699 return err 16700 } 16701 if val == nil { 16702 break 16703 } 16704 { 16705 xtv := string(val) 16706 sv.DigestAlgorithmMnemonic = ptr.String(xtv) 16707 } 16708 16709 case strings.EqualFold("DigestAlgorithmType", t.Name.Local): 16710 val, err := decoder.Value() 16711 if err != nil { 16712 return err 16713 } 16714 if val == nil { 16715 break 16716 } 16717 { 16718 xtv := string(val) 16719 i64, err := strconv.ParseInt(xtv, 10, 64) 16720 if err != nil { 16721 return err 16722 } 16723 sv.DigestAlgorithmType = int32(i64) 16724 } 16725 16726 case strings.EqualFold("DigestValue", t.Name.Local): 16727 val, err := decoder.Value() 16728 if err != nil { 16729 return err 16730 } 16731 if val == nil { 16732 break 16733 } 16734 { 16735 xtv := string(val) 16736 sv.DigestValue = ptr.String(xtv) 16737 } 16738 16739 case strings.EqualFold("DNSKEYRecord", t.Name.Local): 16740 val, err := decoder.Value() 16741 if err != nil { 16742 return err 16743 } 16744 if val == nil { 16745 break 16746 } 16747 { 16748 xtv := string(val) 16749 sv.DNSKEYRecord = ptr.String(xtv) 16750 } 16751 16752 case strings.EqualFold("DSRecord", t.Name.Local): 16753 val, err := decoder.Value() 16754 if err != nil { 16755 return err 16756 } 16757 if val == nil { 16758 break 16759 } 16760 { 16761 xtv := string(val) 16762 sv.DSRecord = ptr.String(xtv) 16763 } 16764 16765 case strings.EqualFold("Flag", t.Name.Local): 16766 val, err := decoder.Value() 16767 if err != nil { 16768 return err 16769 } 16770 if val == nil { 16771 break 16772 } 16773 { 16774 xtv := string(val) 16775 i64, err := strconv.ParseInt(xtv, 10, 64) 16776 if err != nil { 16777 return err 16778 } 16779 sv.Flag = int32(i64) 16780 } 16781 16782 case strings.EqualFold("KeyTag", t.Name.Local): 16783 val, err := decoder.Value() 16784 if err != nil { 16785 return err 16786 } 16787 if val == nil { 16788 break 16789 } 16790 { 16791 xtv := string(val) 16792 i64, err := strconv.ParseInt(xtv, 10, 64) 16793 if err != nil { 16794 return err 16795 } 16796 sv.KeyTag = int32(i64) 16797 } 16798 16799 case strings.EqualFold("KmsArn", t.Name.Local): 16800 val, err := decoder.Value() 16801 if err != nil { 16802 return err 16803 } 16804 if val == nil { 16805 break 16806 } 16807 { 16808 xtv := string(val) 16809 sv.KmsArn = ptr.String(xtv) 16810 } 16811 16812 case strings.EqualFold("LastModifiedDate", t.Name.Local): 16813 val, err := decoder.Value() 16814 if err != nil { 16815 return err 16816 } 16817 if val == nil { 16818 break 16819 } 16820 { 16821 xtv := string(val) 16822 t, err := smithytime.ParseDateTime(xtv) 16823 if err != nil { 16824 return err 16825 } 16826 sv.LastModifiedDate = ptr.Time(t) 16827 } 16828 16829 case strings.EqualFold("Name", t.Name.Local): 16830 val, err := decoder.Value() 16831 if err != nil { 16832 return err 16833 } 16834 if val == nil { 16835 break 16836 } 16837 { 16838 xtv := string(val) 16839 sv.Name = ptr.String(xtv) 16840 } 16841 16842 case strings.EqualFold("PublicKey", t.Name.Local): 16843 val, err := decoder.Value() 16844 if err != nil { 16845 return err 16846 } 16847 if val == nil { 16848 break 16849 } 16850 { 16851 xtv := string(val) 16852 sv.PublicKey = ptr.String(xtv) 16853 } 16854 16855 case strings.EqualFold("SigningAlgorithmMnemonic", t.Name.Local): 16856 val, err := decoder.Value() 16857 if err != nil { 16858 return err 16859 } 16860 if val == nil { 16861 break 16862 } 16863 { 16864 xtv := string(val) 16865 sv.SigningAlgorithmMnemonic = ptr.String(xtv) 16866 } 16867 16868 case strings.EqualFold("SigningAlgorithmType", t.Name.Local): 16869 val, err := decoder.Value() 16870 if err != nil { 16871 return err 16872 } 16873 if val == nil { 16874 break 16875 } 16876 { 16877 xtv := string(val) 16878 i64, err := strconv.ParseInt(xtv, 10, 64) 16879 if err != nil { 16880 return err 16881 } 16882 sv.SigningAlgorithmType = int32(i64) 16883 } 16884 16885 case strings.EqualFold("Status", t.Name.Local): 16886 val, err := decoder.Value() 16887 if err != nil { 16888 return err 16889 } 16890 if val == nil { 16891 break 16892 } 16893 { 16894 xtv := string(val) 16895 sv.Status = ptr.String(xtv) 16896 } 16897 16898 case strings.EqualFold("StatusMessage", t.Name.Local): 16899 val, err := decoder.Value() 16900 if err != nil { 16901 return err 16902 } 16903 if val == nil { 16904 break 16905 } 16906 { 16907 xtv := string(val) 16908 sv.StatusMessage = ptr.String(xtv) 16909 } 16910 16911 default: 16912 // Do nothing and ignore the unexpected tag element 16913 err = decoder.Decoder.Skip() 16914 if err != nil { 16915 return err 16916 } 16917 16918 } 16919 decoder = originalDecoder 16920 } 16921 *v = sv 16922 return nil 16923} 16924 16925func awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(v **types.KeySigningKeyAlreadyExists, decoder smithyxml.NodeDecoder) error { 16926 if v == nil { 16927 return fmt.Errorf("unexpected nil of type %T", v) 16928 } 16929 var sv *types.KeySigningKeyAlreadyExists 16930 if *v == nil { 16931 sv = &types.KeySigningKeyAlreadyExists{} 16932 } else { 16933 sv = *v 16934 } 16935 16936 for { 16937 t, done, err := decoder.Token() 16938 if err != nil { 16939 return err 16940 } 16941 if done { 16942 break 16943 } 16944 originalDecoder := decoder 16945 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16946 switch { 16947 case strings.EqualFold("message", t.Name.Local): 16948 val, err := decoder.Value() 16949 if err != nil { 16950 return err 16951 } 16952 if val == nil { 16953 break 16954 } 16955 { 16956 xtv := string(val) 16957 sv.Message = ptr.String(xtv) 16958 } 16959 16960 default: 16961 // Do nothing and ignore the unexpected tag element 16962 err = decoder.Decoder.Skip() 16963 if err != nil { 16964 return err 16965 } 16966 16967 } 16968 decoder = originalDecoder 16969 } 16970 *v = sv 16971 return nil 16972} 16973 16974func awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(v **types.KeySigningKeyInParentDSRecord, decoder smithyxml.NodeDecoder) error { 16975 if v == nil { 16976 return fmt.Errorf("unexpected nil of type %T", v) 16977 } 16978 var sv *types.KeySigningKeyInParentDSRecord 16979 if *v == nil { 16980 sv = &types.KeySigningKeyInParentDSRecord{} 16981 } else { 16982 sv = *v 16983 } 16984 16985 for { 16986 t, done, err := decoder.Token() 16987 if err != nil { 16988 return err 16989 } 16990 if done { 16991 break 16992 } 16993 originalDecoder := decoder 16994 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16995 switch { 16996 case strings.EqualFold("message", t.Name.Local): 16997 val, err := decoder.Value() 16998 if err != nil { 16999 return err 17000 } 17001 if val == nil { 17002 break 17003 } 17004 { 17005 xtv := string(val) 17006 sv.Message = ptr.String(xtv) 17007 } 17008 17009 default: 17010 // Do nothing and ignore the unexpected tag element 17011 err = decoder.Decoder.Skip() 17012 if err != nil { 17013 return err 17014 } 17015 17016 } 17017 decoder = originalDecoder 17018 } 17019 *v = sv 17020 return nil 17021} 17022 17023func awsRestxml_deserializeDocumentKeySigningKeyInUse(v **types.KeySigningKeyInUse, decoder smithyxml.NodeDecoder) error { 17024 if v == nil { 17025 return fmt.Errorf("unexpected nil of type %T", v) 17026 } 17027 var sv *types.KeySigningKeyInUse 17028 if *v == nil { 17029 sv = &types.KeySigningKeyInUse{} 17030 } else { 17031 sv = *v 17032 } 17033 17034 for { 17035 t, done, err := decoder.Token() 17036 if err != nil { 17037 return err 17038 } 17039 if done { 17040 break 17041 } 17042 originalDecoder := decoder 17043 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17044 switch { 17045 case strings.EqualFold("message", t.Name.Local): 17046 val, err := decoder.Value() 17047 if err != nil { 17048 return err 17049 } 17050 if val == nil { 17051 break 17052 } 17053 { 17054 xtv := string(val) 17055 sv.Message = ptr.String(xtv) 17056 } 17057 17058 default: 17059 // Do nothing and ignore the unexpected tag element 17060 err = decoder.Decoder.Skip() 17061 if err != nil { 17062 return err 17063 } 17064 17065 } 17066 decoder = originalDecoder 17067 } 17068 *v = sv 17069 return nil 17070} 17071 17072func awsRestxml_deserializeDocumentKeySigningKeys(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error { 17073 if v == nil { 17074 return fmt.Errorf("unexpected nil of type %T", v) 17075 } 17076 var sv []types.KeySigningKey 17077 if *v == nil { 17078 sv = make([]types.KeySigningKey, 0) 17079 } else { 17080 sv = *v 17081 } 17082 17083 originalDecoder := decoder 17084 for { 17085 t, done, err := decoder.Token() 17086 if err != nil { 17087 return err 17088 } 17089 if done { 17090 break 17091 } 17092 switch { 17093 case strings.EqualFold("member", t.Name.Local): 17094 var col types.KeySigningKey 17095 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17096 destAddr := &col 17097 if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil { 17098 return err 17099 } 17100 col = *destAddr 17101 sv = append(sv, col) 17102 17103 default: 17104 err = decoder.Decoder.Skip() 17105 if err != nil { 17106 return err 17107 } 17108 17109 } 17110 decoder = originalDecoder 17111 } 17112 *v = sv 17113 return nil 17114} 17115 17116func awsRestxml_deserializeDocumentKeySigningKeysUnwrapped(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error { 17117 var sv []types.KeySigningKey 17118 if *v == nil { 17119 sv = make([]types.KeySigningKey, 0) 17120 } else { 17121 sv = *v 17122 } 17123 17124 switch { 17125 default: 17126 var mv types.KeySigningKey 17127 t := decoder.StartEl 17128 _ = t 17129 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17130 destAddr := &mv 17131 if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil { 17132 return err 17133 } 17134 mv = *destAddr 17135 sv = append(sv, mv) 17136 } 17137 *v = sv 17138 return nil 17139} 17140func awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(v **types.KeySigningKeyWithActiveStatusNotFound, decoder smithyxml.NodeDecoder) error { 17141 if v == nil { 17142 return fmt.Errorf("unexpected nil of type %T", v) 17143 } 17144 var sv *types.KeySigningKeyWithActiveStatusNotFound 17145 if *v == nil { 17146 sv = &types.KeySigningKeyWithActiveStatusNotFound{} 17147 } else { 17148 sv = *v 17149 } 17150 17151 for { 17152 t, done, err := decoder.Token() 17153 if err != nil { 17154 return err 17155 } 17156 if done { 17157 break 17158 } 17159 originalDecoder := decoder 17160 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17161 switch { 17162 case strings.EqualFold("message", t.Name.Local): 17163 val, err := decoder.Value() 17164 if err != nil { 17165 return err 17166 } 17167 if val == nil { 17168 break 17169 } 17170 { 17171 xtv := string(val) 17172 sv.Message = ptr.String(xtv) 17173 } 17174 17175 default: 17176 // Do nothing and ignore the unexpected tag element 17177 err = decoder.Decoder.Skip() 17178 if err != nil { 17179 return err 17180 } 17181 17182 } 17183 decoder = originalDecoder 17184 } 17185 *v = sv 17186 return nil 17187} 17188 17189func awsRestxml_deserializeDocumentLastVPCAssociation(v **types.LastVPCAssociation, decoder smithyxml.NodeDecoder) error { 17190 if v == nil { 17191 return fmt.Errorf("unexpected nil of type %T", v) 17192 } 17193 var sv *types.LastVPCAssociation 17194 if *v == nil { 17195 sv = &types.LastVPCAssociation{} 17196 } else { 17197 sv = *v 17198 } 17199 17200 for { 17201 t, done, err := decoder.Token() 17202 if err != nil { 17203 return err 17204 } 17205 if done { 17206 break 17207 } 17208 originalDecoder := decoder 17209 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17210 switch { 17211 case strings.EqualFold("message", t.Name.Local): 17212 val, err := decoder.Value() 17213 if err != nil { 17214 return err 17215 } 17216 if val == nil { 17217 break 17218 } 17219 { 17220 xtv := string(val) 17221 sv.Message = ptr.String(xtv) 17222 } 17223 17224 default: 17225 // Do nothing and ignore the unexpected tag element 17226 err = decoder.Decoder.Skip() 17227 if err != nil { 17228 return err 17229 } 17230 17231 } 17232 decoder = originalDecoder 17233 } 17234 *v = sv 17235 return nil 17236} 17237 17238func awsRestxml_deserializeDocumentLimitsExceeded(v **types.LimitsExceeded, decoder smithyxml.NodeDecoder) error { 17239 if v == nil { 17240 return fmt.Errorf("unexpected nil of type %T", v) 17241 } 17242 var sv *types.LimitsExceeded 17243 if *v == nil { 17244 sv = &types.LimitsExceeded{} 17245 } else { 17246 sv = *v 17247 } 17248 17249 for { 17250 t, done, err := decoder.Token() 17251 if err != nil { 17252 return err 17253 } 17254 if done { 17255 break 17256 } 17257 originalDecoder := decoder 17258 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17259 switch { 17260 case strings.EqualFold("message", t.Name.Local): 17261 val, err := decoder.Value() 17262 if err != nil { 17263 return err 17264 } 17265 if val == nil { 17266 break 17267 } 17268 { 17269 xtv := string(val) 17270 sv.Message = ptr.String(xtv) 17271 } 17272 17273 default: 17274 // Do nothing and ignore the unexpected tag element 17275 err = decoder.Decoder.Skip() 17276 if err != nil { 17277 return err 17278 } 17279 17280 } 17281 decoder = originalDecoder 17282 } 17283 *v = sv 17284 return nil 17285} 17286 17287func awsRestxml_deserializeDocumentLinkedService(v **types.LinkedService, decoder smithyxml.NodeDecoder) error { 17288 if v == nil { 17289 return fmt.Errorf("unexpected nil of type %T", v) 17290 } 17291 var sv *types.LinkedService 17292 if *v == nil { 17293 sv = &types.LinkedService{} 17294 } else { 17295 sv = *v 17296 } 17297 17298 for { 17299 t, done, err := decoder.Token() 17300 if err != nil { 17301 return err 17302 } 17303 if done { 17304 break 17305 } 17306 originalDecoder := decoder 17307 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17308 switch { 17309 case strings.EqualFold("Description", t.Name.Local): 17310 val, err := decoder.Value() 17311 if err != nil { 17312 return err 17313 } 17314 if val == nil { 17315 break 17316 } 17317 { 17318 xtv := string(val) 17319 sv.Description = ptr.String(xtv) 17320 } 17321 17322 case strings.EqualFold("ServicePrincipal", t.Name.Local): 17323 val, err := decoder.Value() 17324 if err != nil { 17325 return err 17326 } 17327 if val == nil { 17328 break 17329 } 17330 { 17331 xtv := string(val) 17332 sv.ServicePrincipal = ptr.String(xtv) 17333 } 17334 17335 default: 17336 // Do nothing and ignore the unexpected tag element 17337 err = decoder.Decoder.Skip() 17338 if err != nil { 17339 return err 17340 } 17341 17342 } 17343 decoder = originalDecoder 17344 } 17345 *v = sv 17346 return nil 17347} 17348 17349func awsRestxml_deserializeDocumentNoSuchChange(v **types.NoSuchChange, decoder smithyxml.NodeDecoder) error { 17350 if v == nil { 17351 return fmt.Errorf("unexpected nil of type %T", v) 17352 } 17353 var sv *types.NoSuchChange 17354 if *v == nil { 17355 sv = &types.NoSuchChange{} 17356 } else { 17357 sv = *v 17358 } 17359 17360 for { 17361 t, done, err := decoder.Token() 17362 if err != nil { 17363 return err 17364 } 17365 if done { 17366 break 17367 } 17368 originalDecoder := decoder 17369 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17370 switch { 17371 case strings.EqualFold("message", t.Name.Local): 17372 val, err := decoder.Value() 17373 if err != nil { 17374 return err 17375 } 17376 if val == nil { 17377 break 17378 } 17379 { 17380 xtv := string(val) 17381 sv.Message = ptr.String(xtv) 17382 } 17383 17384 default: 17385 // Do nothing and ignore the unexpected tag element 17386 err = decoder.Decoder.Skip() 17387 if err != nil { 17388 return err 17389 } 17390 17391 } 17392 decoder = originalDecoder 17393 } 17394 *v = sv 17395 return nil 17396} 17397 17398func awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(v **types.NoSuchCloudWatchLogsLogGroup, decoder smithyxml.NodeDecoder) error { 17399 if v == nil { 17400 return fmt.Errorf("unexpected nil of type %T", v) 17401 } 17402 var sv *types.NoSuchCloudWatchLogsLogGroup 17403 if *v == nil { 17404 sv = &types.NoSuchCloudWatchLogsLogGroup{} 17405 } else { 17406 sv = *v 17407 } 17408 17409 for { 17410 t, done, err := decoder.Token() 17411 if err != nil { 17412 return err 17413 } 17414 if done { 17415 break 17416 } 17417 originalDecoder := decoder 17418 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17419 switch { 17420 case strings.EqualFold("message", t.Name.Local): 17421 val, err := decoder.Value() 17422 if err != nil { 17423 return err 17424 } 17425 if val == nil { 17426 break 17427 } 17428 { 17429 xtv := string(val) 17430 sv.Message = ptr.String(xtv) 17431 } 17432 17433 default: 17434 // Do nothing and ignore the unexpected tag element 17435 err = decoder.Decoder.Skip() 17436 if err != nil { 17437 return err 17438 } 17439 17440 } 17441 decoder = originalDecoder 17442 } 17443 *v = sv 17444 return nil 17445} 17446 17447func awsRestxml_deserializeDocumentNoSuchDelegationSet(v **types.NoSuchDelegationSet, decoder smithyxml.NodeDecoder) error { 17448 if v == nil { 17449 return fmt.Errorf("unexpected nil of type %T", v) 17450 } 17451 var sv *types.NoSuchDelegationSet 17452 if *v == nil { 17453 sv = &types.NoSuchDelegationSet{} 17454 } else { 17455 sv = *v 17456 } 17457 17458 for { 17459 t, done, err := decoder.Token() 17460 if err != nil { 17461 return err 17462 } 17463 if done { 17464 break 17465 } 17466 originalDecoder := decoder 17467 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17468 switch { 17469 case strings.EqualFold("message", t.Name.Local): 17470 val, err := decoder.Value() 17471 if err != nil { 17472 return err 17473 } 17474 if val == nil { 17475 break 17476 } 17477 { 17478 xtv := string(val) 17479 sv.Message = ptr.String(xtv) 17480 } 17481 17482 default: 17483 // Do nothing and ignore the unexpected tag element 17484 err = decoder.Decoder.Skip() 17485 if err != nil { 17486 return err 17487 } 17488 17489 } 17490 decoder = originalDecoder 17491 } 17492 *v = sv 17493 return nil 17494} 17495 17496func awsRestxml_deserializeDocumentNoSuchGeoLocation(v **types.NoSuchGeoLocation, decoder smithyxml.NodeDecoder) error { 17497 if v == nil { 17498 return fmt.Errorf("unexpected nil of type %T", v) 17499 } 17500 var sv *types.NoSuchGeoLocation 17501 if *v == nil { 17502 sv = &types.NoSuchGeoLocation{} 17503 } else { 17504 sv = *v 17505 } 17506 17507 for { 17508 t, done, err := decoder.Token() 17509 if err != nil { 17510 return err 17511 } 17512 if done { 17513 break 17514 } 17515 originalDecoder := decoder 17516 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17517 switch { 17518 case strings.EqualFold("message", t.Name.Local): 17519 val, err := decoder.Value() 17520 if err != nil { 17521 return err 17522 } 17523 if val == nil { 17524 break 17525 } 17526 { 17527 xtv := string(val) 17528 sv.Message = ptr.String(xtv) 17529 } 17530 17531 default: 17532 // Do nothing and ignore the unexpected tag element 17533 err = decoder.Decoder.Skip() 17534 if err != nil { 17535 return err 17536 } 17537 17538 } 17539 decoder = originalDecoder 17540 } 17541 *v = sv 17542 return nil 17543} 17544 17545func awsRestxml_deserializeDocumentNoSuchHealthCheck(v **types.NoSuchHealthCheck, decoder smithyxml.NodeDecoder) error { 17546 if v == nil { 17547 return fmt.Errorf("unexpected nil of type %T", v) 17548 } 17549 var sv *types.NoSuchHealthCheck 17550 if *v == nil { 17551 sv = &types.NoSuchHealthCheck{} 17552 } else { 17553 sv = *v 17554 } 17555 17556 for { 17557 t, done, err := decoder.Token() 17558 if err != nil { 17559 return err 17560 } 17561 if done { 17562 break 17563 } 17564 originalDecoder := decoder 17565 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17566 switch { 17567 case strings.EqualFold("message", t.Name.Local): 17568 val, err := decoder.Value() 17569 if err != nil { 17570 return err 17571 } 17572 if val == nil { 17573 break 17574 } 17575 { 17576 xtv := string(val) 17577 sv.Message = ptr.String(xtv) 17578 } 17579 17580 default: 17581 // Do nothing and ignore the unexpected tag element 17582 err = decoder.Decoder.Skip() 17583 if err != nil { 17584 return err 17585 } 17586 17587 } 17588 decoder = originalDecoder 17589 } 17590 *v = sv 17591 return nil 17592} 17593 17594func awsRestxml_deserializeDocumentNoSuchHostedZone(v **types.NoSuchHostedZone, decoder smithyxml.NodeDecoder) error { 17595 if v == nil { 17596 return fmt.Errorf("unexpected nil of type %T", v) 17597 } 17598 var sv *types.NoSuchHostedZone 17599 if *v == nil { 17600 sv = &types.NoSuchHostedZone{} 17601 } else { 17602 sv = *v 17603 } 17604 17605 for { 17606 t, done, err := decoder.Token() 17607 if err != nil { 17608 return err 17609 } 17610 if done { 17611 break 17612 } 17613 originalDecoder := decoder 17614 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17615 switch { 17616 case strings.EqualFold("message", t.Name.Local): 17617 val, err := decoder.Value() 17618 if err != nil { 17619 return err 17620 } 17621 if val == nil { 17622 break 17623 } 17624 { 17625 xtv := string(val) 17626 sv.Message = ptr.String(xtv) 17627 } 17628 17629 default: 17630 // Do nothing and ignore the unexpected tag element 17631 err = decoder.Decoder.Skip() 17632 if err != nil { 17633 return err 17634 } 17635 17636 } 17637 decoder = originalDecoder 17638 } 17639 *v = sv 17640 return nil 17641} 17642 17643func awsRestxml_deserializeDocumentNoSuchKeySigningKey(v **types.NoSuchKeySigningKey, decoder smithyxml.NodeDecoder) error { 17644 if v == nil { 17645 return fmt.Errorf("unexpected nil of type %T", v) 17646 } 17647 var sv *types.NoSuchKeySigningKey 17648 if *v == nil { 17649 sv = &types.NoSuchKeySigningKey{} 17650 } else { 17651 sv = *v 17652 } 17653 17654 for { 17655 t, done, err := decoder.Token() 17656 if err != nil { 17657 return err 17658 } 17659 if done { 17660 break 17661 } 17662 originalDecoder := decoder 17663 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17664 switch { 17665 case strings.EqualFold("message", t.Name.Local): 17666 val, err := decoder.Value() 17667 if err != nil { 17668 return err 17669 } 17670 if val == nil { 17671 break 17672 } 17673 { 17674 xtv := string(val) 17675 sv.Message = ptr.String(xtv) 17676 } 17677 17678 default: 17679 // Do nothing and ignore the unexpected tag element 17680 err = decoder.Decoder.Skip() 17681 if err != nil { 17682 return err 17683 } 17684 17685 } 17686 decoder = originalDecoder 17687 } 17688 *v = sv 17689 return nil 17690} 17691 17692func awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(v **types.NoSuchQueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 17693 if v == nil { 17694 return fmt.Errorf("unexpected nil of type %T", v) 17695 } 17696 var sv *types.NoSuchQueryLoggingConfig 17697 if *v == nil { 17698 sv = &types.NoSuchQueryLoggingConfig{} 17699 } else { 17700 sv = *v 17701 } 17702 17703 for { 17704 t, done, err := decoder.Token() 17705 if err != nil { 17706 return err 17707 } 17708 if done { 17709 break 17710 } 17711 originalDecoder := decoder 17712 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17713 switch { 17714 case strings.EqualFold("message", t.Name.Local): 17715 val, err := decoder.Value() 17716 if err != nil { 17717 return err 17718 } 17719 if val == nil { 17720 break 17721 } 17722 { 17723 xtv := string(val) 17724 sv.Message = ptr.String(xtv) 17725 } 17726 17727 default: 17728 // Do nothing and ignore the unexpected tag element 17729 err = decoder.Decoder.Skip() 17730 if err != nil { 17731 return err 17732 } 17733 17734 } 17735 decoder = originalDecoder 17736 } 17737 *v = sv 17738 return nil 17739} 17740 17741func awsRestxml_deserializeDocumentNoSuchTrafficPolicy(v **types.NoSuchTrafficPolicy, decoder smithyxml.NodeDecoder) error { 17742 if v == nil { 17743 return fmt.Errorf("unexpected nil of type %T", v) 17744 } 17745 var sv *types.NoSuchTrafficPolicy 17746 if *v == nil { 17747 sv = &types.NoSuchTrafficPolicy{} 17748 } else { 17749 sv = *v 17750 } 17751 17752 for { 17753 t, done, err := decoder.Token() 17754 if err != nil { 17755 return err 17756 } 17757 if done { 17758 break 17759 } 17760 originalDecoder := decoder 17761 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17762 switch { 17763 case strings.EqualFold("message", t.Name.Local): 17764 val, err := decoder.Value() 17765 if err != nil { 17766 return err 17767 } 17768 if val == nil { 17769 break 17770 } 17771 { 17772 xtv := string(val) 17773 sv.Message = ptr.String(xtv) 17774 } 17775 17776 default: 17777 // Do nothing and ignore the unexpected tag element 17778 err = decoder.Decoder.Skip() 17779 if err != nil { 17780 return err 17781 } 17782 17783 } 17784 decoder = originalDecoder 17785 } 17786 *v = sv 17787 return nil 17788} 17789 17790func awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(v **types.NoSuchTrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 17791 if v == nil { 17792 return fmt.Errorf("unexpected nil of type %T", v) 17793 } 17794 var sv *types.NoSuchTrafficPolicyInstance 17795 if *v == nil { 17796 sv = &types.NoSuchTrafficPolicyInstance{} 17797 } else { 17798 sv = *v 17799 } 17800 17801 for { 17802 t, done, err := decoder.Token() 17803 if err != nil { 17804 return err 17805 } 17806 if done { 17807 break 17808 } 17809 originalDecoder := decoder 17810 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17811 switch { 17812 case strings.EqualFold("message", t.Name.Local): 17813 val, err := decoder.Value() 17814 if err != nil { 17815 return err 17816 } 17817 if val == nil { 17818 break 17819 } 17820 { 17821 xtv := string(val) 17822 sv.Message = ptr.String(xtv) 17823 } 17824 17825 default: 17826 // Do nothing and ignore the unexpected tag element 17827 err = decoder.Decoder.Skip() 17828 if err != nil { 17829 return err 17830 } 17831 17832 } 17833 decoder = originalDecoder 17834 } 17835 *v = sv 17836 return nil 17837} 17838 17839func awsRestxml_deserializeDocumentNotAuthorizedException(v **types.NotAuthorizedException, decoder smithyxml.NodeDecoder) error { 17840 if v == nil { 17841 return fmt.Errorf("unexpected nil of type %T", v) 17842 } 17843 var sv *types.NotAuthorizedException 17844 if *v == nil { 17845 sv = &types.NotAuthorizedException{} 17846 } else { 17847 sv = *v 17848 } 17849 17850 for { 17851 t, done, err := decoder.Token() 17852 if err != nil { 17853 return err 17854 } 17855 if done { 17856 break 17857 } 17858 originalDecoder := decoder 17859 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17860 switch { 17861 case strings.EqualFold("message", t.Name.Local): 17862 val, err := decoder.Value() 17863 if err != nil { 17864 return err 17865 } 17866 if val == nil { 17867 break 17868 } 17869 { 17870 xtv := string(val) 17871 sv.Message = ptr.String(xtv) 17872 } 17873 17874 default: 17875 // Do nothing and ignore the unexpected tag element 17876 err = decoder.Decoder.Skip() 17877 if err != nil { 17878 return err 17879 } 17880 17881 } 17882 decoder = originalDecoder 17883 } 17884 *v = sv 17885 return nil 17886} 17887 17888func awsRestxml_deserializeDocumentPriorRequestNotComplete(v **types.PriorRequestNotComplete, decoder smithyxml.NodeDecoder) error { 17889 if v == nil { 17890 return fmt.Errorf("unexpected nil of type %T", v) 17891 } 17892 var sv *types.PriorRequestNotComplete 17893 if *v == nil { 17894 sv = &types.PriorRequestNotComplete{} 17895 } else { 17896 sv = *v 17897 } 17898 17899 for { 17900 t, done, err := decoder.Token() 17901 if err != nil { 17902 return err 17903 } 17904 if done { 17905 break 17906 } 17907 originalDecoder := decoder 17908 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17909 switch { 17910 case strings.EqualFold("message", t.Name.Local): 17911 val, err := decoder.Value() 17912 if err != nil { 17913 return err 17914 } 17915 if val == nil { 17916 break 17917 } 17918 { 17919 xtv := string(val) 17920 sv.Message = ptr.String(xtv) 17921 } 17922 17923 default: 17924 // Do nothing and ignore the unexpected tag element 17925 err = decoder.Decoder.Skip() 17926 if err != nil { 17927 return err 17928 } 17929 17930 } 17931 decoder = originalDecoder 17932 } 17933 *v = sv 17934 return nil 17935} 17936 17937func awsRestxml_deserializeDocumentPublicZoneVPCAssociation(v **types.PublicZoneVPCAssociation, decoder smithyxml.NodeDecoder) error { 17938 if v == nil { 17939 return fmt.Errorf("unexpected nil of type %T", v) 17940 } 17941 var sv *types.PublicZoneVPCAssociation 17942 if *v == nil { 17943 sv = &types.PublicZoneVPCAssociation{} 17944 } else { 17945 sv = *v 17946 } 17947 17948 for { 17949 t, done, err := decoder.Token() 17950 if err != nil { 17951 return err 17952 } 17953 if done { 17954 break 17955 } 17956 originalDecoder := decoder 17957 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17958 switch { 17959 case strings.EqualFold("message", t.Name.Local): 17960 val, err := decoder.Value() 17961 if err != nil { 17962 return err 17963 } 17964 if val == nil { 17965 break 17966 } 17967 { 17968 xtv := string(val) 17969 sv.Message = ptr.String(xtv) 17970 } 17971 17972 default: 17973 // Do nothing and ignore the unexpected tag element 17974 err = decoder.Decoder.Skip() 17975 if err != nil { 17976 return err 17977 } 17978 17979 } 17980 decoder = originalDecoder 17981 } 17982 *v = sv 17983 return nil 17984} 17985 17986func awsRestxml_deserializeDocumentQueryLoggingConfig(v **types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 17987 if v == nil { 17988 return fmt.Errorf("unexpected nil of type %T", v) 17989 } 17990 var sv *types.QueryLoggingConfig 17991 if *v == nil { 17992 sv = &types.QueryLoggingConfig{} 17993 } else { 17994 sv = *v 17995 } 17996 17997 for { 17998 t, done, err := decoder.Token() 17999 if err != nil { 18000 return err 18001 } 18002 if done { 18003 break 18004 } 18005 originalDecoder := decoder 18006 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18007 switch { 18008 case strings.EqualFold("CloudWatchLogsLogGroupArn", t.Name.Local): 18009 val, err := decoder.Value() 18010 if err != nil { 18011 return err 18012 } 18013 if val == nil { 18014 break 18015 } 18016 { 18017 xtv := string(val) 18018 sv.CloudWatchLogsLogGroupArn = ptr.String(xtv) 18019 } 18020 18021 case strings.EqualFold("HostedZoneId", t.Name.Local): 18022 val, err := decoder.Value() 18023 if err != nil { 18024 return err 18025 } 18026 if val == nil { 18027 break 18028 } 18029 { 18030 xtv := string(val) 18031 sv.HostedZoneId = ptr.String(xtv) 18032 } 18033 18034 case strings.EqualFold("Id", t.Name.Local): 18035 val, err := decoder.Value() 18036 if err != nil { 18037 return err 18038 } 18039 if val == nil { 18040 break 18041 } 18042 { 18043 xtv := string(val) 18044 sv.Id = ptr.String(xtv) 18045 } 18046 18047 default: 18048 // Do nothing and ignore the unexpected tag element 18049 err = decoder.Decoder.Skip() 18050 if err != nil { 18051 return err 18052 } 18053 18054 } 18055 decoder = originalDecoder 18056 } 18057 *v = sv 18058 return nil 18059} 18060 18061func awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(v **types.QueryLoggingConfigAlreadyExists, decoder smithyxml.NodeDecoder) error { 18062 if v == nil { 18063 return fmt.Errorf("unexpected nil of type %T", v) 18064 } 18065 var sv *types.QueryLoggingConfigAlreadyExists 18066 if *v == nil { 18067 sv = &types.QueryLoggingConfigAlreadyExists{} 18068 } else { 18069 sv = *v 18070 } 18071 18072 for { 18073 t, done, err := decoder.Token() 18074 if err != nil { 18075 return err 18076 } 18077 if done { 18078 break 18079 } 18080 originalDecoder := decoder 18081 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18082 switch { 18083 case strings.EqualFold("message", t.Name.Local): 18084 val, err := decoder.Value() 18085 if err != nil { 18086 return err 18087 } 18088 if val == nil { 18089 break 18090 } 18091 { 18092 xtv := string(val) 18093 sv.Message = ptr.String(xtv) 18094 } 18095 18096 default: 18097 // Do nothing and ignore the unexpected tag element 18098 err = decoder.Decoder.Skip() 18099 if err != nil { 18100 return err 18101 } 18102 18103 } 18104 decoder = originalDecoder 18105 } 18106 *v = sv 18107 return nil 18108} 18109 18110func awsRestxml_deserializeDocumentQueryLoggingConfigs(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 18111 if v == nil { 18112 return fmt.Errorf("unexpected nil of type %T", v) 18113 } 18114 var sv []types.QueryLoggingConfig 18115 if *v == nil { 18116 sv = make([]types.QueryLoggingConfig, 0) 18117 } else { 18118 sv = *v 18119 } 18120 18121 originalDecoder := decoder 18122 for { 18123 t, done, err := decoder.Token() 18124 if err != nil { 18125 return err 18126 } 18127 if done { 18128 break 18129 } 18130 switch { 18131 case strings.EqualFold("QueryLoggingConfig", t.Name.Local): 18132 var col types.QueryLoggingConfig 18133 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18134 destAddr := &col 18135 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil { 18136 return err 18137 } 18138 col = *destAddr 18139 sv = append(sv, col) 18140 18141 default: 18142 err = decoder.Decoder.Skip() 18143 if err != nil { 18144 return err 18145 } 18146 18147 } 18148 decoder = originalDecoder 18149 } 18150 *v = sv 18151 return nil 18152} 18153 18154func awsRestxml_deserializeDocumentQueryLoggingConfigsUnwrapped(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error { 18155 var sv []types.QueryLoggingConfig 18156 if *v == nil { 18157 sv = make([]types.QueryLoggingConfig, 0) 18158 } else { 18159 sv = *v 18160 } 18161 18162 switch { 18163 default: 18164 var mv types.QueryLoggingConfig 18165 t := decoder.StartEl 18166 _ = t 18167 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18168 destAddr := &mv 18169 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil { 18170 return err 18171 } 18172 mv = *destAddr 18173 sv = append(sv, mv) 18174 } 18175 *v = sv 18176 return nil 18177} 18178func awsRestxml_deserializeDocumentRecordData(v *[]string, decoder smithyxml.NodeDecoder) error { 18179 if v == nil { 18180 return fmt.Errorf("unexpected nil of type %T", v) 18181 } 18182 var sv []string 18183 if *v == nil { 18184 sv = make([]string, 0) 18185 } else { 18186 sv = *v 18187 } 18188 18189 originalDecoder := decoder 18190 for { 18191 t, done, err := decoder.Token() 18192 if err != nil { 18193 return err 18194 } 18195 if done { 18196 break 18197 } 18198 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18199 decoder = memberDecoder 18200 switch { 18201 case strings.EqualFold("RecordDataEntry", t.Name.Local): 18202 var col string 18203 val, err := decoder.Value() 18204 if err != nil { 18205 return err 18206 } 18207 if val == nil { 18208 break 18209 } 18210 { 18211 xtv := string(val) 18212 col = xtv 18213 } 18214 sv = append(sv, col) 18215 18216 default: 18217 err = decoder.Decoder.Skip() 18218 if err != nil { 18219 return err 18220 } 18221 18222 } 18223 decoder = originalDecoder 18224 } 18225 *v = sv 18226 return nil 18227} 18228 18229func awsRestxml_deserializeDocumentRecordDataUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 18230 var sv []string 18231 if *v == nil { 18232 sv = make([]string, 0) 18233 } else { 18234 sv = *v 18235 } 18236 18237 switch { 18238 default: 18239 var mv string 18240 t := decoder.StartEl 18241 _ = t 18242 val, err := decoder.Value() 18243 if err != nil { 18244 return err 18245 } 18246 if val == nil { 18247 break 18248 } 18249 { 18250 xtv := string(val) 18251 mv = xtv 18252 } 18253 sv = append(sv, mv) 18254 } 18255 *v = sv 18256 return nil 18257} 18258func awsRestxml_deserializeDocumentResourceRecord(v **types.ResourceRecord, decoder smithyxml.NodeDecoder) error { 18259 if v == nil { 18260 return fmt.Errorf("unexpected nil of type %T", v) 18261 } 18262 var sv *types.ResourceRecord 18263 if *v == nil { 18264 sv = &types.ResourceRecord{} 18265 } else { 18266 sv = *v 18267 } 18268 18269 for { 18270 t, done, err := decoder.Token() 18271 if err != nil { 18272 return err 18273 } 18274 if done { 18275 break 18276 } 18277 originalDecoder := decoder 18278 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18279 switch { 18280 case strings.EqualFold("Value", t.Name.Local): 18281 val, err := decoder.Value() 18282 if err != nil { 18283 return err 18284 } 18285 if val == nil { 18286 break 18287 } 18288 { 18289 xtv := string(val) 18290 sv.Value = ptr.String(xtv) 18291 } 18292 18293 default: 18294 // Do nothing and ignore the unexpected tag element 18295 err = decoder.Decoder.Skip() 18296 if err != nil { 18297 return err 18298 } 18299 18300 } 18301 decoder = originalDecoder 18302 } 18303 *v = sv 18304 return nil 18305} 18306 18307func awsRestxml_deserializeDocumentResourceRecords(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error { 18308 if v == nil { 18309 return fmt.Errorf("unexpected nil of type %T", v) 18310 } 18311 var sv []types.ResourceRecord 18312 if *v == nil { 18313 sv = make([]types.ResourceRecord, 0) 18314 } else { 18315 sv = *v 18316 } 18317 18318 originalDecoder := decoder 18319 for { 18320 t, done, err := decoder.Token() 18321 if err != nil { 18322 return err 18323 } 18324 if done { 18325 break 18326 } 18327 switch { 18328 case strings.EqualFold("ResourceRecord", t.Name.Local): 18329 var col types.ResourceRecord 18330 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18331 destAddr := &col 18332 if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil { 18333 return err 18334 } 18335 col = *destAddr 18336 sv = append(sv, col) 18337 18338 default: 18339 err = decoder.Decoder.Skip() 18340 if err != nil { 18341 return err 18342 } 18343 18344 } 18345 decoder = originalDecoder 18346 } 18347 *v = sv 18348 return nil 18349} 18350 18351func awsRestxml_deserializeDocumentResourceRecordsUnwrapped(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error { 18352 var sv []types.ResourceRecord 18353 if *v == nil { 18354 sv = make([]types.ResourceRecord, 0) 18355 } else { 18356 sv = *v 18357 } 18358 18359 switch { 18360 default: 18361 var mv types.ResourceRecord 18362 t := decoder.StartEl 18363 _ = t 18364 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18365 destAddr := &mv 18366 if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil { 18367 return err 18368 } 18369 mv = *destAddr 18370 sv = append(sv, mv) 18371 } 18372 *v = sv 18373 return nil 18374} 18375func awsRestxml_deserializeDocumentResourceRecordSet(v **types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error { 18376 if v == nil { 18377 return fmt.Errorf("unexpected nil of type %T", v) 18378 } 18379 var sv *types.ResourceRecordSet 18380 if *v == nil { 18381 sv = &types.ResourceRecordSet{} 18382 } else { 18383 sv = *v 18384 } 18385 18386 for { 18387 t, done, err := decoder.Token() 18388 if err != nil { 18389 return err 18390 } 18391 if done { 18392 break 18393 } 18394 originalDecoder := decoder 18395 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18396 switch { 18397 case strings.EqualFold("AliasTarget", t.Name.Local): 18398 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18399 if err := awsRestxml_deserializeDocumentAliasTarget(&sv.AliasTarget, nodeDecoder); err != nil { 18400 return err 18401 } 18402 18403 case strings.EqualFold("Failover", t.Name.Local): 18404 val, err := decoder.Value() 18405 if err != nil { 18406 return err 18407 } 18408 if val == nil { 18409 break 18410 } 18411 { 18412 xtv := string(val) 18413 sv.Failover = types.ResourceRecordSetFailover(xtv) 18414 } 18415 18416 case strings.EqualFold("GeoLocation", t.Name.Local): 18417 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18418 if err := awsRestxml_deserializeDocumentGeoLocation(&sv.GeoLocation, nodeDecoder); err != nil { 18419 return err 18420 } 18421 18422 case strings.EqualFold("HealthCheckId", t.Name.Local): 18423 val, err := decoder.Value() 18424 if err != nil { 18425 return err 18426 } 18427 if val == nil { 18428 break 18429 } 18430 { 18431 xtv := string(val) 18432 sv.HealthCheckId = ptr.String(xtv) 18433 } 18434 18435 case strings.EqualFold("MultiValueAnswer", t.Name.Local): 18436 val, err := decoder.Value() 18437 if err != nil { 18438 return err 18439 } 18440 if val == nil { 18441 break 18442 } 18443 { 18444 xtv, err := strconv.ParseBool(string(val)) 18445 if err != nil { 18446 return fmt.Errorf("expected ResourceRecordSetMultiValueAnswer to be of type *bool, got %T instead", val) 18447 } 18448 sv.MultiValueAnswer = ptr.Bool(xtv) 18449 } 18450 18451 case strings.EqualFold("Name", t.Name.Local): 18452 val, err := decoder.Value() 18453 if err != nil { 18454 return err 18455 } 18456 if val == nil { 18457 break 18458 } 18459 { 18460 xtv := string(val) 18461 sv.Name = ptr.String(xtv) 18462 } 18463 18464 case strings.EqualFold("Region", t.Name.Local): 18465 val, err := decoder.Value() 18466 if err != nil { 18467 return err 18468 } 18469 if val == nil { 18470 break 18471 } 18472 { 18473 xtv := string(val) 18474 sv.Region = types.ResourceRecordSetRegion(xtv) 18475 } 18476 18477 case strings.EqualFold("ResourceRecords", t.Name.Local): 18478 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18479 if err := awsRestxml_deserializeDocumentResourceRecords(&sv.ResourceRecords, nodeDecoder); err != nil { 18480 return err 18481 } 18482 18483 case strings.EqualFold("SetIdentifier", t.Name.Local): 18484 val, err := decoder.Value() 18485 if err != nil { 18486 return err 18487 } 18488 if val == nil { 18489 break 18490 } 18491 { 18492 xtv := string(val) 18493 sv.SetIdentifier = ptr.String(xtv) 18494 } 18495 18496 case strings.EqualFold("TrafficPolicyInstanceId", t.Name.Local): 18497 val, err := decoder.Value() 18498 if err != nil { 18499 return err 18500 } 18501 if val == nil { 18502 break 18503 } 18504 { 18505 xtv := string(val) 18506 sv.TrafficPolicyInstanceId = ptr.String(xtv) 18507 } 18508 18509 case strings.EqualFold("TTL", t.Name.Local): 18510 val, err := decoder.Value() 18511 if err != nil { 18512 return err 18513 } 18514 if val == nil { 18515 break 18516 } 18517 { 18518 xtv := string(val) 18519 i64, err := strconv.ParseInt(xtv, 10, 64) 18520 if err != nil { 18521 return err 18522 } 18523 sv.TTL = ptr.Int64(i64) 18524 } 18525 18526 case strings.EqualFold("Type", t.Name.Local): 18527 val, err := decoder.Value() 18528 if err != nil { 18529 return err 18530 } 18531 if val == nil { 18532 break 18533 } 18534 { 18535 xtv := string(val) 18536 sv.Type = types.RRType(xtv) 18537 } 18538 18539 case strings.EqualFold("Weight", t.Name.Local): 18540 val, err := decoder.Value() 18541 if err != nil { 18542 return err 18543 } 18544 if val == nil { 18545 break 18546 } 18547 { 18548 xtv := string(val) 18549 i64, err := strconv.ParseInt(xtv, 10, 64) 18550 if err != nil { 18551 return err 18552 } 18553 sv.Weight = ptr.Int64(i64) 18554 } 18555 18556 default: 18557 // Do nothing and ignore the unexpected tag element 18558 err = decoder.Decoder.Skip() 18559 if err != nil { 18560 return err 18561 } 18562 18563 } 18564 decoder = originalDecoder 18565 } 18566 *v = sv 18567 return nil 18568} 18569 18570func awsRestxml_deserializeDocumentResourceRecordSets(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error { 18571 if v == nil { 18572 return fmt.Errorf("unexpected nil of type %T", v) 18573 } 18574 var sv []types.ResourceRecordSet 18575 if *v == nil { 18576 sv = make([]types.ResourceRecordSet, 0) 18577 } else { 18578 sv = *v 18579 } 18580 18581 originalDecoder := decoder 18582 for { 18583 t, done, err := decoder.Token() 18584 if err != nil { 18585 return err 18586 } 18587 if done { 18588 break 18589 } 18590 switch { 18591 case strings.EqualFold("ResourceRecordSet", t.Name.Local): 18592 var col types.ResourceRecordSet 18593 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18594 destAddr := &col 18595 if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil { 18596 return err 18597 } 18598 col = *destAddr 18599 sv = append(sv, col) 18600 18601 default: 18602 err = decoder.Decoder.Skip() 18603 if err != nil { 18604 return err 18605 } 18606 18607 } 18608 decoder = originalDecoder 18609 } 18610 *v = sv 18611 return nil 18612} 18613 18614func awsRestxml_deserializeDocumentResourceRecordSetsUnwrapped(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error { 18615 var sv []types.ResourceRecordSet 18616 if *v == nil { 18617 sv = make([]types.ResourceRecordSet, 0) 18618 } else { 18619 sv = *v 18620 } 18621 18622 switch { 18623 default: 18624 var mv types.ResourceRecordSet 18625 t := decoder.StartEl 18626 _ = t 18627 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18628 destAddr := &mv 18629 if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil { 18630 return err 18631 } 18632 mv = *destAddr 18633 sv = append(sv, mv) 18634 } 18635 *v = sv 18636 return nil 18637} 18638func awsRestxml_deserializeDocumentResourceTagSet(v **types.ResourceTagSet, decoder smithyxml.NodeDecoder) error { 18639 if v == nil { 18640 return fmt.Errorf("unexpected nil of type %T", v) 18641 } 18642 var sv *types.ResourceTagSet 18643 if *v == nil { 18644 sv = &types.ResourceTagSet{} 18645 } else { 18646 sv = *v 18647 } 18648 18649 for { 18650 t, done, err := decoder.Token() 18651 if err != nil { 18652 return err 18653 } 18654 if done { 18655 break 18656 } 18657 originalDecoder := decoder 18658 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18659 switch { 18660 case strings.EqualFold("ResourceId", t.Name.Local): 18661 val, err := decoder.Value() 18662 if err != nil { 18663 return err 18664 } 18665 if val == nil { 18666 break 18667 } 18668 { 18669 xtv := string(val) 18670 sv.ResourceId = ptr.String(xtv) 18671 } 18672 18673 case strings.EqualFold("ResourceType", t.Name.Local): 18674 val, err := decoder.Value() 18675 if err != nil { 18676 return err 18677 } 18678 if val == nil { 18679 break 18680 } 18681 { 18682 xtv := string(val) 18683 sv.ResourceType = types.TagResourceType(xtv) 18684 } 18685 18686 case strings.EqualFold("Tags", t.Name.Local): 18687 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18688 if err := awsRestxml_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil { 18689 return err 18690 } 18691 18692 default: 18693 // Do nothing and ignore the unexpected tag element 18694 err = decoder.Decoder.Skip() 18695 if err != nil { 18696 return err 18697 } 18698 18699 } 18700 decoder = originalDecoder 18701 } 18702 *v = sv 18703 return nil 18704} 18705 18706func awsRestxml_deserializeDocumentResourceTagSetList(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error { 18707 if v == nil { 18708 return fmt.Errorf("unexpected nil of type %T", v) 18709 } 18710 var sv []types.ResourceTagSet 18711 if *v == nil { 18712 sv = make([]types.ResourceTagSet, 0) 18713 } else { 18714 sv = *v 18715 } 18716 18717 originalDecoder := decoder 18718 for { 18719 t, done, err := decoder.Token() 18720 if err != nil { 18721 return err 18722 } 18723 if done { 18724 break 18725 } 18726 switch { 18727 case strings.EqualFold("ResourceTagSet", t.Name.Local): 18728 var col types.ResourceTagSet 18729 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18730 destAddr := &col 18731 if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil { 18732 return err 18733 } 18734 col = *destAddr 18735 sv = append(sv, col) 18736 18737 default: 18738 err = decoder.Decoder.Skip() 18739 if err != nil { 18740 return err 18741 } 18742 18743 } 18744 decoder = originalDecoder 18745 } 18746 *v = sv 18747 return nil 18748} 18749 18750func awsRestxml_deserializeDocumentResourceTagSetListUnwrapped(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error { 18751 var sv []types.ResourceTagSet 18752 if *v == nil { 18753 sv = make([]types.ResourceTagSet, 0) 18754 } else { 18755 sv = *v 18756 } 18757 18758 switch { 18759 default: 18760 var mv types.ResourceTagSet 18761 t := decoder.StartEl 18762 _ = t 18763 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18764 destAddr := &mv 18765 if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil { 18766 return err 18767 } 18768 mv = *destAddr 18769 sv = append(sv, mv) 18770 } 18771 *v = sv 18772 return nil 18773} 18774func awsRestxml_deserializeDocumentReusableDelegationSetLimit(v **types.ReusableDelegationSetLimit, decoder smithyxml.NodeDecoder) error { 18775 if v == nil { 18776 return fmt.Errorf("unexpected nil of type %T", v) 18777 } 18778 var sv *types.ReusableDelegationSetLimit 18779 if *v == nil { 18780 sv = &types.ReusableDelegationSetLimit{} 18781 } else { 18782 sv = *v 18783 } 18784 18785 for { 18786 t, done, err := decoder.Token() 18787 if err != nil { 18788 return err 18789 } 18790 if done { 18791 break 18792 } 18793 originalDecoder := decoder 18794 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18795 switch { 18796 case strings.EqualFold("Type", t.Name.Local): 18797 val, err := decoder.Value() 18798 if err != nil { 18799 return err 18800 } 18801 if val == nil { 18802 break 18803 } 18804 { 18805 xtv := string(val) 18806 sv.Type = types.ReusableDelegationSetLimitType(xtv) 18807 } 18808 18809 case strings.EqualFold("Value", t.Name.Local): 18810 val, err := decoder.Value() 18811 if err != nil { 18812 return err 18813 } 18814 if val == nil { 18815 break 18816 } 18817 { 18818 xtv := string(val) 18819 i64, err := strconv.ParseInt(xtv, 10, 64) 18820 if err != nil { 18821 return err 18822 } 18823 sv.Value = i64 18824 } 18825 18826 default: 18827 // Do nothing and ignore the unexpected tag element 18828 err = decoder.Decoder.Skip() 18829 if err != nil { 18830 return err 18831 } 18832 18833 } 18834 decoder = originalDecoder 18835 } 18836 *v = sv 18837 return nil 18838} 18839 18840func awsRestxml_deserializeDocumentStatusReport(v **types.StatusReport, decoder smithyxml.NodeDecoder) error { 18841 if v == nil { 18842 return fmt.Errorf("unexpected nil of type %T", v) 18843 } 18844 var sv *types.StatusReport 18845 if *v == nil { 18846 sv = &types.StatusReport{} 18847 } else { 18848 sv = *v 18849 } 18850 18851 for { 18852 t, done, err := decoder.Token() 18853 if err != nil { 18854 return err 18855 } 18856 if done { 18857 break 18858 } 18859 originalDecoder := decoder 18860 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18861 switch { 18862 case strings.EqualFold("CheckedTime", t.Name.Local): 18863 val, err := decoder.Value() 18864 if err != nil { 18865 return err 18866 } 18867 if val == nil { 18868 break 18869 } 18870 { 18871 xtv := string(val) 18872 t, err := smithytime.ParseDateTime(xtv) 18873 if err != nil { 18874 return err 18875 } 18876 sv.CheckedTime = ptr.Time(t) 18877 } 18878 18879 case strings.EqualFold("Status", t.Name.Local): 18880 val, err := decoder.Value() 18881 if err != nil { 18882 return err 18883 } 18884 if val == nil { 18885 break 18886 } 18887 { 18888 xtv := string(val) 18889 sv.Status = ptr.String(xtv) 18890 } 18891 18892 default: 18893 // Do nothing and ignore the unexpected tag element 18894 err = decoder.Decoder.Skip() 18895 if err != nil { 18896 return err 18897 } 18898 18899 } 18900 decoder = originalDecoder 18901 } 18902 *v = sv 18903 return nil 18904} 18905 18906func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error { 18907 if v == nil { 18908 return fmt.Errorf("unexpected nil of type %T", v) 18909 } 18910 var sv *types.Tag 18911 if *v == nil { 18912 sv = &types.Tag{} 18913 } else { 18914 sv = *v 18915 } 18916 18917 for { 18918 t, done, err := decoder.Token() 18919 if err != nil { 18920 return err 18921 } 18922 if done { 18923 break 18924 } 18925 originalDecoder := decoder 18926 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18927 switch { 18928 case strings.EqualFold("Key", t.Name.Local): 18929 val, err := decoder.Value() 18930 if err != nil { 18931 return err 18932 } 18933 if val == nil { 18934 break 18935 } 18936 { 18937 xtv := string(val) 18938 sv.Key = ptr.String(xtv) 18939 } 18940 18941 case strings.EqualFold("Value", t.Name.Local): 18942 val, err := decoder.Value() 18943 if err != nil { 18944 return err 18945 } 18946 if val == nil { 18947 break 18948 } 18949 { 18950 xtv := string(val) 18951 sv.Value = ptr.String(xtv) 18952 } 18953 18954 default: 18955 // Do nothing and ignore the unexpected tag element 18956 err = decoder.Decoder.Skip() 18957 if err != nil { 18958 return err 18959 } 18960 18961 } 18962 decoder = originalDecoder 18963 } 18964 *v = sv 18965 return nil 18966} 18967 18968func awsRestxml_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 18969 if v == nil { 18970 return fmt.Errorf("unexpected nil of type %T", v) 18971 } 18972 var sv []types.Tag 18973 if *v == nil { 18974 sv = make([]types.Tag, 0) 18975 } else { 18976 sv = *v 18977 } 18978 18979 originalDecoder := decoder 18980 for { 18981 t, done, err := decoder.Token() 18982 if err != nil { 18983 return err 18984 } 18985 if done { 18986 break 18987 } 18988 switch { 18989 case strings.EqualFold("Tag", t.Name.Local): 18990 var col types.Tag 18991 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18992 destAddr := &col 18993 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 18994 return err 18995 } 18996 col = *destAddr 18997 sv = append(sv, col) 18998 18999 default: 19000 err = decoder.Decoder.Skip() 19001 if err != nil { 19002 return err 19003 } 19004 19005 } 19006 decoder = originalDecoder 19007 } 19008 *v = sv 19009 return nil 19010} 19011 19012func awsRestxml_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 19013 var sv []types.Tag 19014 if *v == nil { 19015 sv = make([]types.Tag, 0) 19016 } else { 19017 sv = *v 19018 } 19019 19020 switch { 19021 default: 19022 var mv types.Tag 19023 t := decoder.StartEl 19024 _ = t 19025 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19026 destAddr := &mv 19027 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 19028 return err 19029 } 19030 mv = *destAddr 19031 sv = append(sv, mv) 19032 } 19033 *v = sv 19034 return nil 19035} 19036func awsRestxml_deserializeDocumentThrottlingException(v **types.ThrottlingException, decoder smithyxml.NodeDecoder) error { 19037 if v == nil { 19038 return fmt.Errorf("unexpected nil of type %T", v) 19039 } 19040 var sv *types.ThrottlingException 19041 if *v == nil { 19042 sv = &types.ThrottlingException{} 19043 } else { 19044 sv = *v 19045 } 19046 19047 for { 19048 t, done, err := decoder.Token() 19049 if err != nil { 19050 return err 19051 } 19052 if done { 19053 break 19054 } 19055 originalDecoder := decoder 19056 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19057 switch { 19058 case strings.EqualFold("message", t.Name.Local): 19059 val, err := decoder.Value() 19060 if err != nil { 19061 return err 19062 } 19063 if val == nil { 19064 break 19065 } 19066 { 19067 xtv := string(val) 19068 sv.Message = ptr.String(xtv) 19069 } 19070 19071 default: 19072 // Do nothing and ignore the unexpected tag element 19073 err = decoder.Decoder.Skip() 19074 if err != nil { 19075 return err 19076 } 19077 19078 } 19079 decoder = originalDecoder 19080 } 19081 *v = sv 19082 return nil 19083} 19084 19085func awsRestxml_deserializeDocumentTooManyHealthChecks(v **types.TooManyHealthChecks, decoder smithyxml.NodeDecoder) error { 19086 if v == nil { 19087 return fmt.Errorf("unexpected nil of type %T", v) 19088 } 19089 var sv *types.TooManyHealthChecks 19090 if *v == nil { 19091 sv = &types.TooManyHealthChecks{} 19092 } else { 19093 sv = *v 19094 } 19095 19096 for { 19097 t, done, err := decoder.Token() 19098 if err != nil { 19099 return err 19100 } 19101 if done { 19102 break 19103 } 19104 originalDecoder := decoder 19105 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19106 switch { 19107 case strings.EqualFold("message", t.Name.Local): 19108 val, err := decoder.Value() 19109 if err != nil { 19110 return err 19111 } 19112 if val == nil { 19113 break 19114 } 19115 { 19116 xtv := string(val) 19117 sv.Message = ptr.String(xtv) 19118 } 19119 19120 default: 19121 // Do nothing and ignore the unexpected tag element 19122 err = decoder.Decoder.Skip() 19123 if err != nil { 19124 return err 19125 } 19126 19127 } 19128 decoder = originalDecoder 19129 } 19130 *v = sv 19131 return nil 19132} 19133 19134func awsRestxml_deserializeDocumentTooManyHostedZones(v **types.TooManyHostedZones, decoder smithyxml.NodeDecoder) error { 19135 if v == nil { 19136 return fmt.Errorf("unexpected nil of type %T", v) 19137 } 19138 var sv *types.TooManyHostedZones 19139 if *v == nil { 19140 sv = &types.TooManyHostedZones{} 19141 } else { 19142 sv = *v 19143 } 19144 19145 for { 19146 t, done, err := decoder.Token() 19147 if err != nil { 19148 return err 19149 } 19150 if done { 19151 break 19152 } 19153 originalDecoder := decoder 19154 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19155 switch { 19156 case strings.EqualFold("message", t.Name.Local): 19157 val, err := decoder.Value() 19158 if err != nil { 19159 return err 19160 } 19161 if val == nil { 19162 break 19163 } 19164 { 19165 xtv := string(val) 19166 sv.Message = ptr.String(xtv) 19167 } 19168 19169 default: 19170 // Do nothing and ignore the unexpected tag element 19171 err = decoder.Decoder.Skip() 19172 if err != nil { 19173 return err 19174 } 19175 19176 } 19177 decoder = originalDecoder 19178 } 19179 *v = sv 19180 return nil 19181} 19182 19183func awsRestxml_deserializeDocumentTooManyKeySigningKeys(v **types.TooManyKeySigningKeys, decoder smithyxml.NodeDecoder) error { 19184 if v == nil { 19185 return fmt.Errorf("unexpected nil of type %T", v) 19186 } 19187 var sv *types.TooManyKeySigningKeys 19188 if *v == nil { 19189 sv = &types.TooManyKeySigningKeys{} 19190 } else { 19191 sv = *v 19192 } 19193 19194 for { 19195 t, done, err := decoder.Token() 19196 if err != nil { 19197 return err 19198 } 19199 if done { 19200 break 19201 } 19202 originalDecoder := decoder 19203 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19204 switch { 19205 case strings.EqualFold("message", t.Name.Local): 19206 val, err := decoder.Value() 19207 if err != nil { 19208 return err 19209 } 19210 if val == nil { 19211 break 19212 } 19213 { 19214 xtv := string(val) 19215 sv.Message = ptr.String(xtv) 19216 } 19217 19218 default: 19219 // Do nothing and ignore the unexpected tag element 19220 err = decoder.Decoder.Skip() 19221 if err != nil { 19222 return err 19223 } 19224 19225 } 19226 decoder = originalDecoder 19227 } 19228 *v = sv 19229 return nil 19230} 19231 19232func awsRestxml_deserializeDocumentTooManyTrafficPolicies(v **types.TooManyTrafficPolicies, decoder smithyxml.NodeDecoder) error { 19233 if v == nil { 19234 return fmt.Errorf("unexpected nil of type %T", v) 19235 } 19236 var sv *types.TooManyTrafficPolicies 19237 if *v == nil { 19238 sv = &types.TooManyTrafficPolicies{} 19239 } else { 19240 sv = *v 19241 } 19242 19243 for { 19244 t, done, err := decoder.Token() 19245 if err != nil { 19246 return err 19247 } 19248 if done { 19249 break 19250 } 19251 originalDecoder := decoder 19252 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19253 switch { 19254 case strings.EqualFold("message", t.Name.Local): 19255 val, err := decoder.Value() 19256 if err != nil { 19257 return err 19258 } 19259 if val == nil { 19260 break 19261 } 19262 { 19263 xtv := string(val) 19264 sv.Message = ptr.String(xtv) 19265 } 19266 19267 default: 19268 // Do nothing and ignore the unexpected tag element 19269 err = decoder.Decoder.Skip() 19270 if err != nil { 19271 return err 19272 } 19273 19274 } 19275 decoder = originalDecoder 19276 } 19277 *v = sv 19278 return nil 19279} 19280 19281func awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(v **types.TooManyTrafficPolicyInstances, decoder smithyxml.NodeDecoder) error { 19282 if v == nil { 19283 return fmt.Errorf("unexpected nil of type %T", v) 19284 } 19285 var sv *types.TooManyTrafficPolicyInstances 19286 if *v == nil { 19287 sv = &types.TooManyTrafficPolicyInstances{} 19288 } else { 19289 sv = *v 19290 } 19291 19292 for { 19293 t, done, err := decoder.Token() 19294 if err != nil { 19295 return err 19296 } 19297 if done { 19298 break 19299 } 19300 originalDecoder := decoder 19301 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19302 switch { 19303 case strings.EqualFold("message", t.Name.Local): 19304 val, err := decoder.Value() 19305 if err != nil { 19306 return err 19307 } 19308 if val == nil { 19309 break 19310 } 19311 { 19312 xtv := string(val) 19313 sv.Message = ptr.String(xtv) 19314 } 19315 19316 default: 19317 // Do nothing and ignore the unexpected tag element 19318 err = decoder.Decoder.Skip() 19319 if err != nil { 19320 return err 19321 } 19322 19323 } 19324 decoder = originalDecoder 19325 } 19326 *v = sv 19327 return nil 19328} 19329 19330func awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(v **types.TooManyTrafficPolicyVersionsForCurrentPolicy, decoder smithyxml.NodeDecoder) error { 19331 if v == nil { 19332 return fmt.Errorf("unexpected nil of type %T", v) 19333 } 19334 var sv *types.TooManyTrafficPolicyVersionsForCurrentPolicy 19335 if *v == nil { 19336 sv = &types.TooManyTrafficPolicyVersionsForCurrentPolicy{} 19337 } else { 19338 sv = *v 19339 } 19340 19341 for { 19342 t, done, err := decoder.Token() 19343 if err != nil { 19344 return err 19345 } 19346 if done { 19347 break 19348 } 19349 originalDecoder := decoder 19350 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19351 switch { 19352 case strings.EqualFold("message", t.Name.Local): 19353 val, err := decoder.Value() 19354 if err != nil { 19355 return err 19356 } 19357 if val == nil { 19358 break 19359 } 19360 { 19361 xtv := string(val) 19362 sv.Message = ptr.String(xtv) 19363 } 19364 19365 default: 19366 // Do nothing and ignore the unexpected tag element 19367 err = decoder.Decoder.Skip() 19368 if err != nil { 19369 return err 19370 } 19371 19372 } 19373 decoder = originalDecoder 19374 } 19375 *v = sv 19376 return nil 19377} 19378 19379func awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(v **types.TooManyVPCAssociationAuthorizations, decoder smithyxml.NodeDecoder) error { 19380 if v == nil { 19381 return fmt.Errorf("unexpected nil of type %T", v) 19382 } 19383 var sv *types.TooManyVPCAssociationAuthorizations 19384 if *v == nil { 19385 sv = &types.TooManyVPCAssociationAuthorizations{} 19386 } else { 19387 sv = *v 19388 } 19389 19390 for { 19391 t, done, err := decoder.Token() 19392 if err != nil { 19393 return err 19394 } 19395 if done { 19396 break 19397 } 19398 originalDecoder := decoder 19399 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19400 switch { 19401 case strings.EqualFold("message", t.Name.Local): 19402 val, err := decoder.Value() 19403 if err != nil { 19404 return err 19405 } 19406 if val == nil { 19407 break 19408 } 19409 { 19410 xtv := string(val) 19411 sv.Message = ptr.String(xtv) 19412 } 19413 19414 default: 19415 // Do nothing and ignore the unexpected tag element 19416 err = decoder.Decoder.Skip() 19417 if err != nil { 19418 return err 19419 } 19420 19421 } 19422 decoder = originalDecoder 19423 } 19424 *v = sv 19425 return nil 19426} 19427 19428func awsRestxml_deserializeDocumentTrafficPolicies(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error { 19429 if v == nil { 19430 return fmt.Errorf("unexpected nil of type %T", v) 19431 } 19432 var sv []types.TrafficPolicy 19433 if *v == nil { 19434 sv = make([]types.TrafficPolicy, 0) 19435 } else { 19436 sv = *v 19437 } 19438 19439 originalDecoder := decoder 19440 for { 19441 t, done, err := decoder.Token() 19442 if err != nil { 19443 return err 19444 } 19445 if done { 19446 break 19447 } 19448 switch { 19449 case strings.EqualFold("TrafficPolicy", t.Name.Local): 19450 var col types.TrafficPolicy 19451 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19452 destAddr := &col 19453 if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil { 19454 return err 19455 } 19456 col = *destAddr 19457 sv = append(sv, col) 19458 19459 default: 19460 err = decoder.Decoder.Skip() 19461 if err != nil { 19462 return err 19463 } 19464 19465 } 19466 decoder = originalDecoder 19467 } 19468 *v = sv 19469 return nil 19470} 19471 19472func awsRestxml_deserializeDocumentTrafficPoliciesUnwrapped(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error { 19473 var sv []types.TrafficPolicy 19474 if *v == nil { 19475 sv = make([]types.TrafficPolicy, 0) 19476 } else { 19477 sv = *v 19478 } 19479 19480 switch { 19481 default: 19482 var mv types.TrafficPolicy 19483 t := decoder.StartEl 19484 _ = t 19485 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19486 destAddr := &mv 19487 if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil { 19488 return err 19489 } 19490 mv = *destAddr 19491 sv = append(sv, mv) 19492 } 19493 *v = sv 19494 return nil 19495} 19496func awsRestxml_deserializeDocumentTrafficPolicy(v **types.TrafficPolicy, decoder smithyxml.NodeDecoder) error { 19497 if v == nil { 19498 return fmt.Errorf("unexpected nil of type %T", v) 19499 } 19500 var sv *types.TrafficPolicy 19501 if *v == nil { 19502 sv = &types.TrafficPolicy{} 19503 } else { 19504 sv = *v 19505 } 19506 19507 for { 19508 t, done, err := decoder.Token() 19509 if err != nil { 19510 return err 19511 } 19512 if done { 19513 break 19514 } 19515 originalDecoder := decoder 19516 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19517 switch { 19518 case strings.EqualFold("Comment", t.Name.Local): 19519 val, err := decoder.Value() 19520 if err != nil { 19521 return err 19522 } 19523 if val == nil { 19524 break 19525 } 19526 { 19527 xtv := string(val) 19528 sv.Comment = ptr.String(xtv) 19529 } 19530 19531 case strings.EqualFold("Document", t.Name.Local): 19532 val, err := decoder.Value() 19533 if err != nil { 19534 return err 19535 } 19536 if val == nil { 19537 break 19538 } 19539 { 19540 xtv := string(val) 19541 sv.Document = ptr.String(xtv) 19542 } 19543 19544 case strings.EqualFold("Id", t.Name.Local): 19545 val, err := decoder.Value() 19546 if err != nil { 19547 return err 19548 } 19549 if val == nil { 19550 break 19551 } 19552 { 19553 xtv := string(val) 19554 sv.Id = ptr.String(xtv) 19555 } 19556 19557 case strings.EqualFold("Name", t.Name.Local): 19558 val, err := decoder.Value() 19559 if err != nil { 19560 return err 19561 } 19562 if val == nil { 19563 break 19564 } 19565 { 19566 xtv := string(val) 19567 sv.Name = ptr.String(xtv) 19568 } 19569 19570 case strings.EqualFold("Type", t.Name.Local): 19571 val, err := decoder.Value() 19572 if err != nil { 19573 return err 19574 } 19575 if val == nil { 19576 break 19577 } 19578 { 19579 xtv := string(val) 19580 sv.Type = types.RRType(xtv) 19581 } 19582 19583 case strings.EqualFold("Version", t.Name.Local): 19584 val, err := decoder.Value() 19585 if err != nil { 19586 return err 19587 } 19588 if val == nil { 19589 break 19590 } 19591 { 19592 xtv := string(val) 19593 i64, err := strconv.ParseInt(xtv, 10, 64) 19594 if err != nil { 19595 return err 19596 } 19597 sv.Version = ptr.Int32(int32(i64)) 19598 } 19599 19600 default: 19601 // Do nothing and ignore the unexpected tag element 19602 err = decoder.Decoder.Skip() 19603 if err != nil { 19604 return err 19605 } 19606 19607 } 19608 decoder = originalDecoder 19609 } 19610 *v = sv 19611 return nil 19612} 19613 19614func awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(v **types.TrafficPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error { 19615 if v == nil { 19616 return fmt.Errorf("unexpected nil of type %T", v) 19617 } 19618 var sv *types.TrafficPolicyAlreadyExists 19619 if *v == nil { 19620 sv = &types.TrafficPolicyAlreadyExists{} 19621 } else { 19622 sv = *v 19623 } 19624 19625 for { 19626 t, done, err := decoder.Token() 19627 if err != nil { 19628 return err 19629 } 19630 if done { 19631 break 19632 } 19633 originalDecoder := decoder 19634 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19635 switch { 19636 case strings.EqualFold("message", t.Name.Local): 19637 val, err := decoder.Value() 19638 if err != nil { 19639 return err 19640 } 19641 if val == nil { 19642 break 19643 } 19644 { 19645 xtv := string(val) 19646 sv.Message = ptr.String(xtv) 19647 } 19648 19649 default: 19650 // Do nothing and ignore the unexpected tag element 19651 err = decoder.Decoder.Skip() 19652 if err != nil { 19653 return err 19654 } 19655 19656 } 19657 decoder = originalDecoder 19658 } 19659 *v = sv 19660 return nil 19661} 19662 19663func awsRestxml_deserializeDocumentTrafficPolicyInstance(v **types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 19664 if v == nil { 19665 return fmt.Errorf("unexpected nil of type %T", v) 19666 } 19667 var sv *types.TrafficPolicyInstance 19668 if *v == nil { 19669 sv = &types.TrafficPolicyInstance{} 19670 } else { 19671 sv = *v 19672 } 19673 19674 for { 19675 t, done, err := decoder.Token() 19676 if err != nil { 19677 return err 19678 } 19679 if done { 19680 break 19681 } 19682 originalDecoder := decoder 19683 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19684 switch { 19685 case strings.EqualFold("HostedZoneId", t.Name.Local): 19686 val, err := decoder.Value() 19687 if err != nil { 19688 return err 19689 } 19690 if val == nil { 19691 break 19692 } 19693 { 19694 xtv := string(val) 19695 sv.HostedZoneId = ptr.String(xtv) 19696 } 19697 19698 case strings.EqualFold("Id", t.Name.Local): 19699 val, err := decoder.Value() 19700 if err != nil { 19701 return err 19702 } 19703 if val == nil { 19704 break 19705 } 19706 { 19707 xtv := string(val) 19708 sv.Id = ptr.String(xtv) 19709 } 19710 19711 case strings.EqualFold("Message", t.Name.Local): 19712 val, err := decoder.Value() 19713 if err != nil { 19714 return err 19715 } 19716 if val == nil { 19717 break 19718 } 19719 { 19720 xtv := string(val) 19721 sv.Message = ptr.String(xtv) 19722 } 19723 19724 case strings.EqualFold("Name", t.Name.Local): 19725 val, err := decoder.Value() 19726 if err != nil { 19727 return err 19728 } 19729 if val == nil { 19730 break 19731 } 19732 { 19733 xtv := string(val) 19734 sv.Name = ptr.String(xtv) 19735 } 19736 19737 case strings.EqualFold("State", t.Name.Local): 19738 val, err := decoder.Value() 19739 if err != nil { 19740 return err 19741 } 19742 if val == nil { 19743 break 19744 } 19745 { 19746 xtv := string(val) 19747 sv.State = ptr.String(xtv) 19748 } 19749 19750 case strings.EqualFold("TrafficPolicyId", t.Name.Local): 19751 val, err := decoder.Value() 19752 if err != nil { 19753 return err 19754 } 19755 if val == nil { 19756 break 19757 } 19758 { 19759 xtv := string(val) 19760 sv.TrafficPolicyId = ptr.String(xtv) 19761 } 19762 19763 case strings.EqualFold("TrafficPolicyType", t.Name.Local): 19764 val, err := decoder.Value() 19765 if err != nil { 19766 return err 19767 } 19768 if val == nil { 19769 break 19770 } 19771 { 19772 xtv := string(val) 19773 sv.TrafficPolicyType = types.RRType(xtv) 19774 } 19775 19776 case strings.EqualFold("TrafficPolicyVersion", t.Name.Local): 19777 val, err := decoder.Value() 19778 if err != nil { 19779 return err 19780 } 19781 if val == nil { 19782 break 19783 } 19784 { 19785 xtv := string(val) 19786 i64, err := strconv.ParseInt(xtv, 10, 64) 19787 if err != nil { 19788 return err 19789 } 19790 sv.TrafficPolicyVersion = ptr.Int32(int32(i64)) 19791 } 19792 19793 case strings.EqualFold("TTL", t.Name.Local): 19794 val, err := decoder.Value() 19795 if err != nil { 19796 return err 19797 } 19798 if val == nil { 19799 break 19800 } 19801 { 19802 xtv := string(val) 19803 i64, err := strconv.ParseInt(xtv, 10, 64) 19804 if err != nil { 19805 return err 19806 } 19807 sv.TTL = ptr.Int64(i64) 19808 } 19809 19810 default: 19811 // Do nothing and ignore the unexpected tag element 19812 err = decoder.Decoder.Skip() 19813 if err != nil { 19814 return err 19815 } 19816 19817 } 19818 decoder = originalDecoder 19819 } 19820 *v = sv 19821 return nil 19822} 19823 19824func awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(v **types.TrafficPolicyInstanceAlreadyExists, decoder smithyxml.NodeDecoder) error { 19825 if v == nil { 19826 return fmt.Errorf("unexpected nil of type %T", v) 19827 } 19828 var sv *types.TrafficPolicyInstanceAlreadyExists 19829 if *v == nil { 19830 sv = &types.TrafficPolicyInstanceAlreadyExists{} 19831 } else { 19832 sv = *v 19833 } 19834 19835 for { 19836 t, done, err := decoder.Token() 19837 if err != nil { 19838 return err 19839 } 19840 if done { 19841 break 19842 } 19843 originalDecoder := decoder 19844 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19845 switch { 19846 case strings.EqualFold("message", t.Name.Local): 19847 val, err := decoder.Value() 19848 if err != nil { 19849 return err 19850 } 19851 if val == nil { 19852 break 19853 } 19854 { 19855 xtv := string(val) 19856 sv.Message = ptr.String(xtv) 19857 } 19858 19859 default: 19860 // Do nothing and ignore the unexpected tag element 19861 err = decoder.Decoder.Skip() 19862 if err != nil { 19863 return err 19864 } 19865 19866 } 19867 decoder = originalDecoder 19868 } 19869 *v = sv 19870 return nil 19871} 19872 19873func awsRestxml_deserializeDocumentTrafficPolicyInstances(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 19874 if v == nil { 19875 return fmt.Errorf("unexpected nil of type %T", v) 19876 } 19877 var sv []types.TrafficPolicyInstance 19878 if *v == nil { 19879 sv = make([]types.TrafficPolicyInstance, 0) 19880 } else { 19881 sv = *v 19882 } 19883 19884 originalDecoder := decoder 19885 for { 19886 t, done, err := decoder.Token() 19887 if err != nil { 19888 return err 19889 } 19890 if done { 19891 break 19892 } 19893 switch { 19894 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local): 19895 var col types.TrafficPolicyInstance 19896 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19897 destAddr := &col 19898 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil { 19899 return err 19900 } 19901 col = *destAddr 19902 sv = append(sv, col) 19903 19904 default: 19905 err = decoder.Decoder.Skip() 19906 if err != nil { 19907 return err 19908 } 19909 19910 } 19911 decoder = originalDecoder 19912 } 19913 *v = sv 19914 return nil 19915} 19916 19917func awsRestxml_deserializeDocumentTrafficPolicyInstancesUnwrapped(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error { 19918 var sv []types.TrafficPolicyInstance 19919 if *v == nil { 19920 sv = make([]types.TrafficPolicyInstance, 0) 19921 } else { 19922 sv = *v 19923 } 19924 19925 switch { 19926 default: 19927 var mv types.TrafficPolicyInstance 19928 t := decoder.StartEl 19929 _ = t 19930 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19931 destAddr := &mv 19932 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil { 19933 return err 19934 } 19935 mv = *destAddr 19936 sv = append(sv, mv) 19937 } 19938 *v = sv 19939 return nil 19940} 19941func awsRestxml_deserializeDocumentTrafficPolicyInUse(v **types.TrafficPolicyInUse, decoder smithyxml.NodeDecoder) error { 19942 if v == nil { 19943 return fmt.Errorf("unexpected nil of type %T", v) 19944 } 19945 var sv *types.TrafficPolicyInUse 19946 if *v == nil { 19947 sv = &types.TrafficPolicyInUse{} 19948 } else { 19949 sv = *v 19950 } 19951 19952 for { 19953 t, done, err := decoder.Token() 19954 if err != nil { 19955 return err 19956 } 19957 if done { 19958 break 19959 } 19960 originalDecoder := decoder 19961 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19962 switch { 19963 case strings.EqualFold("message", t.Name.Local): 19964 val, err := decoder.Value() 19965 if err != nil { 19966 return err 19967 } 19968 if val == nil { 19969 break 19970 } 19971 { 19972 xtv := string(val) 19973 sv.Message = ptr.String(xtv) 19974 } 19975 19976 default: 19977 // Do nothing and ignore the unexpected tag element 19978 err = decoder.Decoder.Skip() 19979 if err != nil { 19980 return err 19981 } 19982 19983 } 19984 decoder = originalDecoder 19985 } 19986 *v = sv 19987 return nil 19988} 19989 19990func awsRestxml_deserializeDocumentTrafficPolicySummaries(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error { 19991 if v == nil { 19992 return fmt.Errorf("unexpected nil of type %T", v) 19993 } 19994 var sv []types.TrafficPolicySummary 19995 if *v == nil { 19996 sv = make([]types.TrafficPolicySummary, 0) 19997 } else { 19998 sv = *v 19999 } 20000 20001 originalDecoder := decoder 20002 for { 20003 t, done, err := decoder.Token() 20004 if err != nil { 20005 return err 20006 } 20007 if done { 20008 break 20009 } 20010 switch { 20011 case strings.EqualFold("TrafficPolicySummary", t.Name.Local): 20012 var col types.TrafficPolicySummary 20013 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20014 destAddr := &col 20015 if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil { 20016 return err 20017 } 20018 col = *destAddr 20019 sv = append(sv, col) 20020 20021 default: 20022 err = decoder.Decoder.Skip() 20023 if err != nil { 20024 return err 20025 } 20026 20027 } 20028 decoder = originalDecoder 20029 } 20030 *v = sv 20031 return nil 20032} 20033 20034func awsRestxml_deserializeDocumentTrafficPolicySummariesUnwrapped(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error { 20035 var sv []types.TrafficPolicySummary 20036 if *v == nil { 20037 sv = make([]types.TrafficPolicySummary, 0) 20038 } else { 20039 sv = *v 20040 } 20041 20042 switch { 20043 default: 20044 var mv types.TrafficPolicySummary 20045 t := decoder.StartEl 20046 _ = t 20047 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20048 destAddr := &mv 20049 if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil { 20050 return err 20051 } 20052 mv = *destAddr 20053 sv = append(sv, mv) 20054 } 20055 *v = sv 20056 return nil 20057} 20058func awsRestxml_deserializeDocumentTrafficPolicySummary(v **types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error { 20059 if v == nil { 20060 return fmt.Errorf("unexpected nil of type %T", v) 20061 } 20062 var sv *types.TrafficPolicySummary 20063 if *v == nil { 20064 sv = &types.TrafficPolicySummary{} 20065 } else { 20066 sv = *v 20067 } 20068 20069 for { 20070 t, done, err := decoder.Token() 20071 if err != nil { 20072 return err 20073 } 20074 if done { 20075 break 20076 } 20077 originalDecoder := decoder 20078 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20079 switch { 20080 case strings.EqualFold("Id", t.Name.Local): 20081 val, err := decoder.Value() 20082 if err != nil { 20083 return err 20084 } 20085 if val == nil { 20086 break 20087 } 20088 { 20089 xtv := string(val) 20090 sv.Id = ptr.String(xtv) 20091 } 20092 20093 case strings.EqualFold("LatestVersion", t.Name.Local): 20094 val, err := decoder.Value() 20095 if err != nil { 20096 return err 20097 } 20098 if val == nil { 20099 break 20100 } 20101 { 20102 xtv := string(val) 20103 i64, err := strconv.ParseInt(xtv, 10, 64) 20104 if err != nil { 20105 return err 20106 } 20107 sv.LatestVersion = ptr.Int32(int32(i64)) 20108 } 20109 20110 case strings.EqualFold("Name", t.Name.Local): 20111 val, err := decoder.Value() 20112 if err != nil { 20113 return err 20114 } 20115 if val == nil { 20116 break 20117 } 20118 { 20119 xtv := string(val) 20120 sv.Name = ptr.String(xtv) 20121 } 20122 20123 case strings.EqualFold("TrafficPolicyCount", t.Name.Local): 20124 val, err := decoder.Value() 20125 if err != nil { 20126 return err 20127 } 20128 if val == nil { 20129 break 20130 } 20131 { 20132 xtv := string(val) 20133 i64, err := strconv.ParseInt(xtv, 10, 64) 20134 if err != nil { 20135 return err 20136 } 20137 sv.TrafficPolicyCount = ptr.Int32(int32(i64)) 20138 } 20139 20140 case strings.EqualFold("Type", t.Name.Local): 20141 val, err := decoder.Value() 20142 if err != nil { 20143 return err 20144 } 20145 if val == nil { 20146 break 20147 } 20148 { 20149 xtv := string(val) 20150 sv.Type = types.RRType(xtv) 20151 } 20152 20153 default: 20154 // Do nothing and ignore the unexpected tag element 20155 err = decoder.Decoder.Skip() 20156 if err != nil { 20157 return err 20158 } 20159 20160 } 20161 decoder = originalDecoder 20162 } 20163 *v = sv 20164 return nil 20165} 20166 20167func awsRestxml_deserializeDocumentVPC(v **types.VPC, decoder smithyxml.NodeDecoder) error { 20168 if v == nil { 20169 return fmt.Errorf("unexpected nil of type %T", v) 20170 } 20171 var sv *types.VPC 20172 if *v == nil { 20173 sv = &types.VPC{} 20174 } else { 20175 sv = *v 20176 } 20177 20178 for { 20179 t, done, err := decoder.Token() 20180 if err != nil { 20181 return err 20182 } 20183 if done { 20184 break 20185 } 20186 originalDecoder := decoder 20187 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20188 switch { 20189 case strings.EqualFold("VPCId", t.Name.Local): 20190 val, err := decoder.Value() 20191 if err != nil { 20192 return err 20193 } 20194 if val == nil { 20195 break 20196 } 20197 { 20198 xtv := string(val) 20199 sv.VPCId = ptr.String(xtv) 20200 } 20201 20202 case strings.EqualFold("VPCRegion", t.Name.Local): 20203 val, err := decoder.Value() 20204 if err != nil { 20205 return err 20206 } 20207 if val == nil { 20208 break 20209 } 20210 { 20211 xtv := string(val) 20212 sv.VPCRegion = types.VPCRegion(xtv) 20213 } 20214 20215 default: 20216 // Do nothing and ignore the unexpected tag element 20217 err = decoder.Decoder.Skip() 20218 if err != nil { 20219 return err 20220 } 20221 20222 } 20223 decoder = originalDecoder 20224 } 20225 *v = sv 20226 return nil 20227} 20228 20229func awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(v **types.VPCAssociationAuthorizationNotFound, decoder smithyxml.NodeDecoder) error { 20230 if v == nil { 20231 return fmt.Errorf("unexpected nil of type %T", v) 20232 } 20233 var sv *types.VPCAssociationAuthorizationNotFound 20234 if *v == nil { 20235 sv = &types.VPCAssociationAuthorizationNotFound{} 20236 } else { 20237 sv = *v 20238 } 20239 20240 for { 20241 t, done, err := decoder.Token() 20242 if err != nil { 20243 return err 20244 } 20245 if done { 20246 break 20247 } 20248 originalDecoder := decoder 20249 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20250 switch { 20251 case strings.EqualFold("message", t.Name.Local): 20252 val, err := decoder.Value() 20253 if err != nil { 20254 return err 20255 } 20256 if val == nil { 20257 break 20258 } 20259 { 20260 xtv := string(val) 20261 sv.Message = ptr.String(xtv) 20262 } 20263 20264 default: 20265 // Do nothing and ignore the unexpected tag element 20266 err = decoder.Decoder.Skip() 20267 if err != nil { 20268 return err 20269 } 20270 20271 } 20272 decoder = originalDecoder 20273 } 20274 *v = sv 20275 return nil 20276} 20277 20278func awsRestxml_deserializeDocumentVPCAssociationNotFound(v **types.VPCAssociationNotFound, decoder smithyxml.NodeDecoder) error { 20279 if v == nil { 20280 return fmt.Errorf("unexpected nil of type %T", v) 20281 } 20282 var sv *types.VPCAssociationNotFound 20283 if *v == nil { 20284 sv = &types.VPCAssociationNotFound{} 20285 } else { 20286 sv = *v 20287 } 20288 20289 for { 20290 t, done, err := decoder.Token() 20291 if err != nil { 20292 return err 20293 } 20294 if done { 20295 break 20296 } 20297 originalDecoder := decoder 20298 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20299 switch { 20300 case strings.EqualFold("message", t.Name.Local): 20301 val, err := decoder.Value() 20302 if err != nil { 20303 return err 20304 } 20305 if val == nil { 20306 break 20307 } 20308 { 20309 xtv := string(val) 20310 sv.Message = ptr.String(xtv) 20311 } 20312 20313 default: 20314 // Do nothing and ignore the unexpected tag element 20315 err = decoder.Decoder.Skip() 20316 if err != nil { 20317 return err 20318 } 20319 20320 } 20321 decoder = originalDecoder 20322 } 20323 *v = sv 20324 return nil 20325} 20326 20327func awsRestxml_deserializeDocumentVPCs(v *[]types.VPC, decoder smithyxml.NodeDecoder) error { 20328 if v == nil { 20329 return fmt.Errorf("unexpected nil of type %T", v) 20330 } 20331 var sv []types.VPC 20332 if *v == nil { 20333 sv = make([]types.VPC, 0) 20334 } else { 20335 sv = *v 20336 } 20337 20338 originalDecoder := decoder 20339 for { 20340 t, done, err := decoder.Token() 20341 if err != nil { 20342 return err 20343 } 20344 if done { 20345 break 20346 } 20347 switch { 20348 case strings.EqualFold("VPC", t.Name.Local): 20349 var col types.VPC 20350 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20351 destAddr := &col 20352 if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil { 20353 return err 20354 } 20355 col = *destAddr 20356 sv = append(sv, col) 20357 20358 default: 20359 err = decoder.Decoder.Skip() 20360 if err != nil { 20361 return err 20362 } 20363 20364 } 20365 decoder = originalDecoder 20366 } 20367 *v = sv 20368 return nil 20369} 20370 20371func awsRestxml_deserializeDocumentVPCsUnwrapped(v *[]types.VPC, decoder smithyxml.NodeDecoder) error { 20372 var sv []types.VPC 20373 if *v == nil { 20374 sv = make([]types.VPC, 0) 20375 } else { 20376 sv = *v 20377 } 20378 20379 switch { 20380 default: 20381 var mv types.VPC 20382 t := decoder.StartEl 20383 _ = t 20384 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20385 destAddr := &mv 20386 if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil { 20387 return err 20388 } 20389 mv = *destAddr 20390 sv = append(sv, mv) 20391 } 20392 *v = sv 20393 return nil 20394} 20395