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