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