1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package neptune 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/neptune/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_deserializeOpAddRoleToDBCluster struct { 27} 28 29func (*awsAwsquery_deserializeOpAddRoleToDBCluster) ID() string { 30 return "OperationDeserializer" 31} 32 33func (m *awsAwsquery_deserializeOpAddRoleToDBCluster) 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_deserializeOpErrorAddRoleToDBCluster(response, &metadata) 48 } 49 output := &AddRoleToDBClusterOutput{} 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_deserializeOpErrorAddRoleToDBCluster(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("DBClusterNotFoundFault", errorCode): 87 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 88 89 case strings.EqualFold("DBClusterRoleAlreadyExists", errorCode): 90 return awsAwsquery_deserializeErrorDBClusterRoleAlreadyExistsFault(response, errorBody) 91 92 case strings.EqualFold("DBClusterRoleQuotaExceeded", errorCode): 93 return awsAwsquery_deserializeErrorDBClusterRoleQuotaExceededFault(response, errorBody) 94 95 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 96 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 97 98 default: 99 genericError := &smithy.GenericAPIError{ 100 Code: errorCode, 101 Message: errorMessage, 102 } 103 return genericError 104 105 } 106} 107 108type awsAwsquery_deserializeOpAddSourceIdentifierToSubscription struct { 109} 110 111func (*awsAwsquery_deserializeOpAddSourceIdentifierToSubscription) ID() string { 112 return "OperationDeserializer" 113} 114 115func (m *awsAwsquery_deserializeOpAddSourceIdentifierToSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 116 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 117) { 118 out, metadata, err = next.HandleDeserialize(ctx, in) 119 if err != nil { 120 return out, metadata, err 121 } 122 123 response, ok := out.RawResponse.(*smithyhttp.Response) 124 if !ok { 125 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 126 } 127 128 if response.StatusCode < 200 || response.StatusCode >= 300 { 129 return out, metadata, awsAwsquery_deserializeOpErrorAddSourceIdentifierToSubscription(response, &metadata) 130 } 131 output := &AddSourceIdentifierToSubscriptionOutput{} 132 out.Result = output 133 134 var buff [1024]byte 135 ringBuffer := smithyio.NewRingBuffer(buff[:]) 136 body := io.TeeReader(response.Body, ringBuffer) 137 rootDecoder := xml.NewDecoder(body) 138 t, err := smithyxml.FetchRootElement(rootDecoder) 139 if err == io.EOF { 140 return out, metadata, nil 141 } 142 if err != nil { 143 var snapshot bytes.Buffer 144 io.Copy(&snapshot, ringBuffer) 145 return out, metadata, &smithy.DeserializationError{ 146 Err: fmt.Errorf("failed to decode response body, %w", err), 147 Snapshot: snapshot.Bytes(), 148 } 149 } 150 151 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 152 t, err = decoder.GetElement("AddSourceIdentifierToSubscriptionResult") 153 if err != nil { 154 var snapshot bytes.Buffer 155 io.Copy(&snapshot, ringBuffer) 156 err = &smithy.DeserializationError{ 157 Err: fmt.Errorf("failed to decode response body, %w", err), 158 Snapshot: snapshot.Bytes(), 159 } 160 return out, metadata, err 161 } 162 163 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 164 err = awsAwsquery_deserializeOpDocumentAddSourceIdentifierToSubscriptionOutput(&output, decoder) 165 if err != nil { 166 var snapshot bytes.Buffer 167 io.Copy(&snapshot, ringBuffer) 168 err = &smithy.DeserializationError{ 169 Err: fmt.Errorf("failed to decode response body, %w", err), 170 Snapshot: snapshot.Bytes(), 171 } 172 return out, metadata, err 173 } 174 175 return out, metadata, err 176} 177 178func awsAwsquery_deserializeOpErrorAddSourceIdentifierToSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 179 var errorBuffer bytes.Buffer 180 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 181 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 182 } 183 errorBody := bytes.NewReader(errorBuffer.Bytes()) 184 185 errorCode := "UnknownError" 186 errorMessage := errorCode 187 188 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 189 if err != nil { 190 return err 191 } 192 if reqID := errorComponents.RequestID; len(reqID) != 0 { 193 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 194 } 195 if len(errorComponents.Code) != 0 { 196 errorCode = errorComponents.Code 197 } 198 if len(errorComponents.Message) != 0 { 199 errorMessage = errorComponents.Message 200 } 201 errorBody.Seek(0, io.SeekStart) 202 switch { 203 case strings.EqualFold("SourceNotFound", errorCode): 204 return awsAwsquery_deserializeErrorSourceNotFoundFault(response, errorBody) 205 206 case strings.EqualFold("SubscriptionNotFound", errorCode): 207 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 208 209 default: 210 genericError := &smithy.GenericAPIError{ 211 Code: errorCode, 212 Message: errorMessage, 213 } 214 return genericError 215 216 } 217} 218 219type awsAwsquery_deserializeOpAddTagsToResource struct { 220} 221 222func (*awsAwsquery_deserializeOpAddTagsToResource) ID() string { 223 return "OperationDeserializer" 224} 225 226func (m *awsAwsquery_deserializeOpAddTagsToResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 227 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 228) { 229 out, metadata, err = next.HandleDeserialize(ctx, in) 230 if err != nil { 231 return out, metadata, err 232 } 233 234 response, ok := out.RawResponse.(*smithyhttp.Response) 235 if !ok { 236 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 237 } 238 239 if response.StatusCode < 200 || response.StatusCode >= 300 { 240 return out, metadata, awsAwsquery_deserializeOpErrorAddTagsToResource(response, &metadata) 241 } 242 output := &AddTagsToResourceOutput{} 243 out.Result = output 244 245 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 246 return out, metadata, &smithy.DeserializationError{ 247 Err: fmt.Errorf("failed to discard response body, %w", err), 248 } 249 } 250 251 return out, metadata, err 252} 253 254func awsAwsquery_deserializeOpErrorAddTagsToResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 255 var errorBuffer bytes.Buffer 256 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 257 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 258 } 259 errorBody := bytes.NewReader(errorBuffer.Bytes()) 260 261 errorCode := "UnknownError" 262 errorMessage := errorCode 263 264 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 265 if err != nil { 266 return err 267 } 268 if reqID := errorComponents.RequestID; len(reqID) != 0 { 269 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 270 } 271 if len(errorComponents.Code) != 0 { 272 errorCode = errorComponents.Code 273 } 274 if len(errorComponents.Message) != 0 { 275 errorMessage = errorComponents.Message 276 } 277 errorBody.Seek(0, io.SeekStart) 278 switch { 279 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 280 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 281 282 case strings.EqualFold("DBInstanceNotFound", errorCode): 283 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 284 285 case strings.EqualFold("DBSnapshotNotFound", errorCode): 286 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 287 288 default: 289 genericError := &smithy.GenericAPIError{ 290 Code: errorCode, 291 Message: errorMessage, 292 } 293 return genericError 294 295 } 296} 297 298type awsAwsquery_deserializeOpApplyPendingMaintenanceAction struct { 299} 300 301func (*awsAwsquery_deserializeOpApplyPendingMaintenanceAction) ID() string { 302 return "OperationDeserializer" 303} 304 305func (m *awsAwsquery_deserializeOpApplyPendingMaintenanceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 306 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 307) { 308 out, metadata, err = next.HandleDeserialize(ctx, in) 309 if err != nil { 310 return out, metadata, err 311 } 312 313 response, ok := out.RawResponse.(*smithyhttp.Response) 314 if !ok { 315 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 316 } 317 318 if response.StatusCode < 200 || response.StatusCode >= 300 { 319 return out, metadata, awsAwsquery_deserializeOpErrorApplyPendingMaintenanceAction(response, &metadata) 320 } 321 output := &ApplyPendingMaintenanceActionOutput{} 322 out.Result = output 323 324 var buff [1024]byte 325 ringBuffer := smithyio.NewRingBuffer(buff[:]) 326 body := io.TeeReader(response.Body, ringBuffer) 327 rootDecoder := xml.NewDecoder(body) 328 t, err := smithyxml.FetchRootElement(rootDecoder) 329 if err == io.EOF { 330 return out, metadata, nil 331 } 332 if err != nil { 333 var snapshot bytes.Buffer 334 io.Copy(&snapshot, ringBuffer) 335 return out, metadata, &smithy.DeserializationError{ 336 Err: fmt.Errorf("failed to decode response body, %w", err), 337 Snapshot: snapshot.Bytes(), 338 } 339 } 340 341 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 342 t, err = decoder.GetElement("ApplyPendingMaintenanceActionResult") 343 if err != nil { 344 var snapshot bytes.Buffer 345 io.Copy(&snapshot, ringBuffer) 346 err = &smithy.DeserializationError{ 347 Err: fmt.Errorf("failed to decode response body, %w", err), 348 Snapshot: snapshot.Bytes(), 349 } 350 return out, metadata, err 351 } 352 353 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 354 err = awsAwsquery_deserializeOpDocumentApplyPendingMaintenanceActionOutput(&output, decoder) 355 if err != nil { 356 var snapshot bytes.Buffer 357 io.Copy(&snapshot, ringBuffer) 358 err = &smithy.DeserializationError{ 359 Err: fmt.Errorf("failed to decode response body, %w", err), 360 Snapshot: snapshot.Bytes(), 361 } 362 return out, metadata, err 363 } 364 365 return out, metadata, err 366} 367 368func awsAwsquery_deserializeOpErrorApplyPendingMaintenanceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 369 var errorBuffer bytes.Buffer 370 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 371 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 372 } 373 errorBody := bytes.NewReader(errorBuffer.Bytes()) 374 375 errorCode := "UnknownError" 376 errorMessage := errorCode 377 378 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 379 if err != nil { 380 return err 381 } 382 if reqID := errorComponents.RequestID; len(reqID) != 0 { 383 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 384 } 385 if len(errorComponents.Code) != 0 { 386 errorCode = errorComponents.Code 387 } 388 if len(errorComponents.Message) != 0 { 389 errorMessage = errorComponents.Message 390 } 391 errorBody.Seek(0, io.SeekStart) 392 switch { 393 case strings.EqualFold("ResourceNotFoundFault", errorCode): 394 return awsAwsquery_deserializeErrorResourceNotFoundFault(response, errorBody) 395 396 default: 397 genericError := &smithy.GenericAPIError{ 398 Code: errorCode, 399 Message: errorMessage, 400 } 401 return genericError 402 403 } 404} 405 406type awsAwsquery_deserializeOpCopyDBClusterParameterGroup struct { 407} 408 409func (*awsAwsquery_deserializeOpCopyDBClusterParameterGroup) ID() string { 410 return "OperationDeserializer" 411} 412 413func (m *awsAwsquery_deserializeOpCopyDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 414 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 415) { 416 out, metadata, err = next.HandleDeserialize(ctx, in) 417 if err != nil { 418 return out, metadata, err 419 } 420 421 response, ok := out.RawResponse.(*smithyhttp.Response) 422 if !ok { 423 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 424 } 425 426 if response.StatusCode < 200 || response.StatusCode >= 300 { 427 return out, metadata, awsAwsquery_deserializeOpErrorCopyDBClusterParameterGroup(response, &metadata) 428 } 429 output := &CopyDBClusterParameterGroupOutput{} 430 out.Result = output 431 432 var buff [1024]byte 433 ringBuffer := smithyio.NewRingBuffer(buff[:]) 434 body := io.TeeReader(response.Body, ringBuffer) 435 rootDecoder := xml.NewDecoder(body) 436 t, err := smithyxml.FetchRootElement(rootDecoder) 437 if err == io.EOF { 438 return out, metadata, nil 439 } 440 if err != nil { 441 var snapshot bytes.Buffer 442 io.Copy(&snapshot, ringBuffer) 443 return out, metadata, &smithy.DeserializationError{ 444 Err: fmt.Errorf("failed to decode response body, %w", err), 445 Snapshot: snapshot.Bytes(), 446 } 447 } 448 449 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 450 t, err = decoder.GetElement("CopyDBClusterParameterGroupResult") 451 if err != nil { 452 var snapshot bytes.Buffer 453 io.Copy(&snapshot, ringBuffer) 454 err = &smithy.DeserializationError{ 455 Err: fmt.Errorf("failed to decode response body, %w", err), 456 Snapshot: snapshot.Bytes(), 457 } 458 return out, metadata, err 459 } 460 461 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 462 err = awsAwsquery_deserializeOpDocumentCopyDBClusterParameterGroupOutput(&output, decoder) 463 if err != nil { 464 var snapshot bytes.Buffer 465 io.Copy(&snapshot, ringBuffer) 466 err = &smithy.DeserializationError{ 467 Err: fmt.Errorf("failed to decode response body, %w", err), 468 Snapshot: snapshot.Bytes(), 469 } 470 return out, metadata, err 471 } 472 473 return out, metadata, err 474} 475 476func awsAwsquery_deserializeOpErrorCopyDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 477 var errorBuffer bytes.Buffer 478 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 479 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 480 } 481 errorBody := bytes.NewReader(errorBuffer.Bytes()) 482 483 errorCode := "UnknownError" 484 errorMessage := errorCode 485 486 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 487 if err != nil { 488 return err 489 } 490 if reqID := errorComponents.RequestID; len(reqID) != 0 { 491 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 492 } 493 if len(errorComponents.Code) != 0 { 494 errorCode = errorComponents.Code 495 } 496 if len(errorComponents.Message) != 0 { 497 errorMessage = errorComponents.Message 498 } 499 errorBody.Seek(0, io.SeekStart) 500 switch { 501 case strings.EqualFold("DBParameterGroupAlreadyExists", errorCode): 502 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 503 504 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 505 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 506 507 case strings.EqualFold("DBParameterGroupQuotaExceeded", errorCode): 508 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 509 510 default: 511 genericError := &smithy.GenericAPIError{ 512 Code: errorCode, 513 Message: errorMessage, 514 } 515 return genericError 516 517 } 518} 519 520type awsAwsquery_deserializeOpCopyDBClusterSnapshot struct { 521} 522 523func (*awsAwsquery_deserializeOpCopyDBClusterSnapshot) ID() string { 524 return "OperationDeserializer" 525} 526 527func (m *awsAwsquery_deserializeOpCopyDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 528 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 529) { 530 out, metadata, err = next.HandleDeserialize(ctx, in) 531 if err != nil { 532 return out, metadata, err 533 } 534 535 response, ok := out.RawResponse.(*smithyhttp.Response) 536 if !ok { 537 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 538 } 539 540 if response.StatusCode < 200 || response.StatusCode >= 300 { 541 return out, metadata, awsAwsquery_deserializeOpErrorCopyDBClusterSnapshot(response, &metadata) 542 } 543 output := &CopyDBClusterSnapshotOutput{} 544 out.Result = output 545 546 var buff [1024]byte 547 ringBuffer := smithyio.NewRingBuffer(buff[:]) 548 body := io.TeeReader(response.Body, ringBuffer) 549 rootDecoder := xml.NewDecoder(body) 550 t, err := smithyxml.FetchRootElement(rootDecoder) 551 if err == io.EOF { 552 return out, metadata, nil 553 } 554 if err != nil { 555 var snapshot bytes.Buffer 556 io.Copy(&snapshot, ringBuffer) 557 return out, metadata, &smithy.DeserializationError{ 558 Err: fmt.Errorf("failed to decode response body, %w", err), 559 Snapshot: snapshot.Bytes(), 560 } 561 } 562 563 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 564 t, err = decoder.GetElement("CopyDBClusterSnapshotResult") 565 if err != nil { 566 var snapshot bytes.Buffer 567 io.Copy(&snapshot, ringBuffer) 568 err = &smithy.DeserializationError{ 569 Err: fmt.Errorf("failed to decode response body, %w", err), 570 Snapshot: snapshot.Bytes(), 571 } 572 return out, metadata, err 573 } 574 575 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 576 err = awsAwsquery_deserializeOpDocumentCopyDBClusterSnapshotOutput(&output, decoder) 577 if err != nil { 578 var snapshot bytes.Buffer 579 io.Copy(&snapshot, ringBuffer) 580 err = &smithy.DeserializationError{ 581 Err: fmt.Errorf("failed to decode response body, %w", err), 582 Snapshot: snapshot.Bytes(), 583 } 584 return out, metadata, err 585 } 586 587 return out, metadata, err 588} 589 590func awsAwsquery_deserializeOpErrorCopyDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 591 var errorBuffer bytes.Buffer 592 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 593 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 594 } 595 errorBody := bytes.NewReader(errorBuffer.Bytes()) 596 597 errorCode := "UnknownError" 598 errorMessage := errorCode 599 600 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 601 if err != nil { 602 return err 603 } 604 if reqID := errorComponents.RequestID; len(reqID) != 0 { 605 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 606 } 607 if len(errorComponents.Code) != 0 { 608 errorCode = errorComponents.Code 609 } 610 if len(errorComponents.Message) != 0 { 611 errorMessage = errorComponents.Message 612 } 613 errorBody.Seek(0, io.SeekStart) 614 switch { 615 case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): 616 return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) 617 618 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 619 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 620 621 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 622 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 623 624 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 625 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 626 627 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 628 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 629 630 case strings.EqualFold("SnapshotQuotaExceeded", errorCode): 631 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 632 633 default: 634 genericError := &smithy.GenericAPIError{ 635 Code: errorCode, 636 Message: errorMessage, 637 } 638 return genericError 639 640 } 641} 642 643type awsAwsquery_deserializeOpCopyDBParameterGroup struct { 644} 645 646func (*awsAwsquery_deserializeOpCopyDBParameterGroup) ID() string { 647 return "OperationDeserializer" 648} 649 650func (m *awsAwsquery_deserializeOpCopyDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 651 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 652) { 653 out, metadata, err = next.HandleDeserialize(ctx, in) 654 if err != nil { 655 return out, metadata, err 656 } 657 658 response, ok := out.RawResponse.(*smithyhttp.Response) 659 if !ok { 660 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 661 } 662 663 if response.StatusCode < 200 || response.StatusCode >= 300 { 664 return out, metadata, awsAwsquery_deserializeOpErrorCopyDBParameterGroup(response, &metadata) 665 } 666 output := &CopyDBParameterGroupOutput{} 667 out.Result = output 668 669 var buff [1024]byte 670 ringBuffer := smithyio.NewRingBuffer(buff[:]) 671 body := io.TeeReader(response.Body, ringBuffer) 672 rootDecoder := xml.NewDecoder(body) 673 t, err := smithyxml.FetchRootElement(rootDecoder) 674 if err == io.EOF { 675 return out, metadata, nil 676 } 677 if err != nil { 678 var snapshot bytes.Buffer 679 io.Copy(&snapshot, ringBuffer) 680 return out, metadata, &smithy.DeserializationError{ 681 Err: fmt.Errorf("failed to decode response body, %w", err), 682 Snapshot: snapshot.Bytes(), 683 } 684 } 685 686 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 687 t, err = decoder.GetElement("CopyDBParameterGroupResult") 688 if err != nil { 689 var snapshot bytes.Buffer 690 io.Copy(&snapshot, ringBuffer) 691 err = &smithy.DeserializationError{ 692 Err: fmt.Errorf("failed to decode response body, %w", err), 693 Snapshot: snapshot.Bytes(), 694 } 695 return out, metadata, err 696 } 697 698 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 699 err = awsAwsquery_deserializeOpDocumentCopyDBParameterGroupOutput(&output, decoder) 700 if err != nil { 701 var snapshot bytes.Buffer 702 io.Copy(&snapshot, ringBuffer) 703 err = &smithy.DeserializationError{ 704 Err: fmt.Errorf("failed to decode response body, %w", err), 705 Snapshot: snapshot.Bytes(), 706 } 707 return out, metadata, err 708 } 709 710 return out, metadata, err 711} 712 713func awsAwsquery_deserializeOpErrorCopyDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 714 var errorBuffer bytes.Buffer 715 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 716 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 717 } 718 errorBody := bytes.NewReader(errorBuffer.Bytes()) 719 720 errorCode := "UnknownError" 721 errorMessage := errorCode 722 723 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 724 if err != nil { 725 return err 726 } 727 if reqID := errorComponents.RequestID; len(reqID) != 0 { 728 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 729 } 730 if len(errorComponents.Code) != 0 { 731 errorCode = errorComponents.Code 732 } 733 if len(errorComponents.Message) != 0 { 734 errorMessage = errorComponents.Message 735 } 736 errorBody.Seek(0, io.SeekStart) 737 switch { 738 case strings.EqualFold("DBParameterGroupAlreadyExists", errorCode): 739 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 740 741 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 742 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 743 744 case strings.EqualFold("DBParameterGroupQuotaExceeded", errorCode): 745 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 746 747 default: 748 genericError := &smithy.GenericAPIError{ 749 Code: errorCode, 750 Message: errorMessage, 751 } 752 return genericError 753 754 } 755} 756 757type awsAwsquery_deserializeOpCreateDBCluster struct { 758} 759 760func (*awsAwsquery_deserializeOpCreateDBCluster) ID() string { 761 return "OperationDeserializer" 762} 763 764func (m *awsAwsquery_deserializeOpCreateDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 765 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 766) { 767 out, metadata, err = next.HandleDeserialize(ctx, in) 768 if err != nil { 769 return out, metadata, err 770 } 771 772 response, ok := out.RawResponse.(*smithyhttp.Response) 773 if !ok { 774 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 775 } 776 777 if response.StatusCode < 200 || response.StatusCode >= 300 { 778 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBCluster(response, &metadata) 779 } 780 output := &CreateDBClusterOutput{} 781 out.Result = output 782 783 var buff [1024]byte 784 ringBuffer := smithyio.NewRingBuffer(buff[:]) 785 body := io.TeeReader(response.Body, ringBuffer) 786 rootDecoder := xml.NewDecoder(body) 787 t, err := smithyxml.FetchRootElement(rootDecoder) 788 if err == io.EOF { 789 return out, metadata, nil 790 } 791 if err != nil { 792 var snapshot bytes.Buffer 793 io.Copy(&snapshot, ringBuffer) 794 return out, metadata, &smithy.DeserializationError{ 795 Err: fmt.Errorf("failed to decode response body, %w", err), 796 Snapshot: snapshot.Bytes(), 797 } 798 } 799 800 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 801 t, err = decoder.GetElement("CreateDBClusterResult") 802 if err != nil { 803 var snapshot bytes.Buffer 804 io.Copy(&snapshot, ringBuffer) 805 err = &smithy.DeserializationError{ 806 Err: fmt.Errorf("failed to decode response body, %w", err), 807 Snapshot: snapshot.Bytes(), 808 } 809 return out, metadata, err 810 } 811 812 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 813 err = awsAwsquery_deserializeOpDocumentCreateDBClusterOutput(&output, decoder) 814 if err != nil { 815 var snapshot bytes.Buffer 816 io.Copy(&snapshot, ringBuffer) 817 err = &smithy.DeserializationError{ 818 Err: fmt.Errorf("failed to decode response body, %w", err), 819 Snapshot: snapshot.Bytes(), 820 } 821 return out, metadata, err 822 } 823 824 return out, metadata, err 825} 826 827func awsAwsquery_deserializeOpErrorCreateDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 828 var errorBuffer bytes.Buffer 829 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 830 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 831 } 832 errorBody := bytes.NewReader(errorBuffer.Bytes()) 833 834 errorCode := "UnknownError" 835 errorMessage := errorCode 836 837 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 838 if err != nil { 839 return err 840 } 841 if reqID := errorComponents.RequestID; len(reqID) != 0 { 842 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 843 } 844 if len(errorComponents.Code) != 0 { 845 errorCode = errorComponents.Code 846 } 847 if len(errorComponents.Message) != 0 { 848 errorMessage = errorComponents.Message 849 } 850 errorBody.Seek(0, io.SeekStart) 851 switch { 852 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 853 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 854 855 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 856 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 857 858 case strings.EqualFold("DBClusterParameterGroupNotFound", errorCode): 859 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 860 861 case strings.EqualFold("DBClusterQuotaExceededFault", errorCode): 862 return awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response, errorBody) 863 864 case strings.EqualFold("DBInstanceNotFound", errorCode): 865 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 866 867 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 868 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 869 870 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 871 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 872 873 case strings.EqualFold("InsufficientStorageClusterCapacity", errorCode): 874 return awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response, errorBody) 875 876 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 877 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 878 879 case strings.EqualFold("InvalidDBInstanceState", errorCode): 880 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 881 882 case strings.EqualFold("InvalidDBSubnetGroupStateFault", errorCode): 883 return awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response, errorBody) 884 885 case strings.EqualFold("InvalidSubnet", errorCode): 886 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 887 888 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 889 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 890 891 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 892 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 893 894 case strings.EqualFold("StorageQuotaExceeded", errorCode): 895 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 896 897 default: 898 genericError := &smithy.GenericAPIError{ 899 Code: errorCode, 900 Message: errorMessage, 901 } 902 return genericError 903 904 } 905} 906 907type awsAwsquery_deserializeOpCreateDBClusterEndpoint struct { 908} 909 910func (*awsAwsquery_deserializeOpCreateDBClusterEndpoint) ID() string { 911 return "OperationDeserializer" 912} 913 914func (m *awsAwsquery_deserializeOpCreateDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 915 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 916) { 917 out, metadata, err = next.HandleDeserialize(ctx, in) 918 if err != nil { 919 return out, metadata, err 920 } 921 922 response, ok := out.RawResponse.(*smithyhttp.Response) 923 if !ok { 924 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 925 } 926 927 if response.StatusCode < 200 || response.StatusCode >= 300 { 928 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBClusterEndpoint(response, &metadata) 929 } 930 output := &CreateDBClusterEndpointOutput{} 931 out.Result = output 932 933 var buff [1024]byte 934 ringBuffer := smithyio.NewRingBuffer(buff[:]) 935 body := io.TeeReader(response.Body, ringBuffer) 936 rootDecoder := xml.NewDecoder(body) 937 t, err := smithyxml.FetchRootElement(rootDecoder) 938 if err == io.EOF { 939 return out, metadata, nil 940 } 941 if err != nil { 942 var snapshot bytes.Buffer 943 io.Copy(&snapshot, ringBuffer) 944 return out, metadata, &smithy.DeserializationError{ 945 Err: fmt.Errorf("failed to decode response body, %w", err), 946 Snapshot: snapshot.Bytes(), 947 } 948 } 949 950 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 951 t, err = decoder.GetElement("CreateDBClusterEndpointResult") 952 if err != nil { 953 var snapshot bytes.Buffer 954 io.Copy(&snapshot, ringBuffer) 955 err = &smithy.DeserializationError{ 956 Err: fmt.Errorf("failed to decode response body, %w", err), 957 Snapshot: snapshot.Bytes(), 958 } 959 return out, metadata, err 960 } 961 962 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 963 err = awsAwsquery_deserializeOpDocumentCreateDBClusterEndpointOutput(&output, decoder) 964 if err != nil { 965 var snapshot bytes.Buffer 966 io.Copy(&snapshot, ringBuffer) 967 err = &smithy.DeserializationError{ 968 Err: fmt.Errorf("failed to decode response body, %w", err), 969 Snapshot: snapshot.Bytes(), 970 } 971 return out, metadata, err 972 } 973 974 return out, metadata, err 975} 976 977func awsAwsquery_deserializeOpErrorCreateDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 978 var errorBuffer bytes.Buffer 979 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 980 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 981 } 982 errorBody := bytes.NewReader(errorBuffer.Bytes()) 983 984 errorCode := "UnknownError" 985 errorMessage := errorCode 986 987 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 988 if err != nil { 989 return err 990 } 991 if reqID := errorComponents.RequestID; len(reqID) != 0 { 992 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 993 } 994 if len(errorComponents.Code) != 0 { 995 errorCode = errorComponents.Code 996 } 997 if len(errorComponents.Message) != 0 { 998 errorMessage = errorComponents.Message 999 } 1000 errorBody.Seek(0, io.SeekStart) 1001 switch { 1002 case strings.EqualFold("DBClusterEndpointAlreadyExistsFault", errorCode): 1003 return awsAwsquery_deserializeErrorDBClusterEndpointAlreadyExistsFault(response, errorBody) 1004 1005 case strings.EqualFold("DBClusterEndpointQuotaExceededFault", errorCode): 1006 return awsAwsquery_deserializeErrorDBClusterEndpointQuotaExceededFault(response, errorBody) 1007 1008 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1009 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1010 1011 case strings.EqualFold("DBInstanceNotFound", errorCode): 1012 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 1013 1014 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1015 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1016 1017 case strings.EqualFold("InvalidDBInstanceState", errorCode): 1018 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 1019 1020 default: 1021 genericError := &smithy.GenericAPIError{ 1022 Code: errorCode, 1023 Message: errorMessage, 1024 } 1025 return genericError 1026 1027 } 1028} 1029 1030type awsAwsquery_deserializeOpCreateDBClusterParameterGroup struct { 1031} 1032 1033func (*awsAwsquery_deserializeOpCreateDBClusterParameterGroup) ID() string { 1034 return "OperationDeserializer" 1035} 1036 1037func (m *awsAwsquery_deserializeOpCreateDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1038 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1039) { 1040 out, metadata, err = next.HandleDeserialize(ctx, in) 1041 if err != nil { 1042 return out, metadata, err 1043 } 1044 1045 response, ok := out.RawResponse.(*smithyhttp.Response) 1046 if !ok { 1047 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1048 } 1049 1050 if response.StatusCode < 200 || response.StatusCode >= 300 { 1051 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBClusterParameterGroup(response, &metadata) 1052 } 1053 output := &CreateDBClusterParameterGroupOutput{} 1054 out.Result = output 1055 1056 var buff [1024]byte 1057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1058 body := io.TeeReader(response.Body, ringBuffer) 1059 rootDecoder := xml.NewDecoder(body) 1060 t, err := smithyxml.FetchRootElement(rootDecoder) 1061 if err == io.EOF { 1062 return out, metadata, nil 1063 } 1064 if err != nil { 1065 var snapshot bytes.Buffer 1066 io.Copy(&snapshot, ringBuffer) 1067 return out, metadata, &smithy.DeserializationError{ 1068 Err: fmt.Errorf("failed to decode response body, %w", err), 1069 Snapshot: snapshot.Bytes(), 1070 } 1071 } 1072 1073 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1074 t, err = decoder.GetElement("CreateDBClusterParameterGroupResult") 1075 if err != nil { 1076 var snapshot bytes.Buffer 1077 io.Copy(&snapshot, ringBuffer) 1078 err = &smithy.DeserializationError{ 1079 Err: fmt.Errorf("failed to decode response body, %w", err), 1080 Snapshot: snapshot.Bytes(), 1081 } 1082 return out, metadata, err 1083 } 1084 1085 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1086 err = awsAwsquery_deserializeOpDocumentCreateDBClusterParameterGroupOutput(&output, decoder) 1087 if err != nil { 1088 var snapshot bytes.Buffer 1089 io.Copy(&snapshot, ringBuffer) 1090 err = &smithy.DeserializationError{ 1091 Err: fmt.Errorf("failed to decode response body, %w", err), 1092 Snapshot: snapshot.Bytes(), 1093 } 1094 return out, metadata, err 1095 } 1096 1097 return out, metadata, err 1098} 1099 1100func awsAwsquery_deserializeOpErrorCreateDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1101 var errorBuffer bytes.Buffer 1102 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1103 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1104 } 1105 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1106 1107 errorCode := "UnknownError" 1108 errorMessage := errorCode 1109 1110 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1111 if err != nil { 1112 return err 1113 } 1114 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1115 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1116 } 1117 if len(errorComponents.Code) != 0 { 1118 errorCode = errorComponents.Code 1119 } 1120 if len(errorComponents.Message) != 0 { 1121 errorMessage = errorComponents.Message 1122 } 1123 errorBody.Seek(0, io.SeekStart) 1124 switch { 1125 case strings.EqualFold("DBParameterGroupAlreadyExists", errorCode): 1126 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 1127 1128 case strings.EqualFold("DBParameterGroupQuotaExceeded", errorCode): 1129 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 1130 1131 default: 1132 genericError := &smithy.GenericAPIError{ 1133 Code: errorCode, 1134 Message: errorMessage, 1135 } 1136 return genericError 1137 1138 } 1139} 1140 1141type awsAwsquery_deserializeOpCreateDBClusterSnapshot struct { 1142} 1143 1144func (*awsAwsquery_deserializeOpCreateDBClusterSnapshot) ID() string { 1145 return "OperationDeserializer" 1146} 1147 1148func (m *awsAwsquery_deserializeOpCreateDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1149 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1150) { 1151 out, metadata, err = next.HandleDeserialize(ctx, in) 1152 if err != nil { 1153 return out, metadata, err 1154 } 1155 1156 response, ok := out.RawResponse.(*smithyhttp.Response) 1157 if !ok { 1158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1159 } 1160 1161 if response.StatusCode < 200 || response.StatusCode >= 300 { 1162 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBClusterSnapshot(response, &metadata) 1163 } 1164 output := &CreateDBClusterSnapshotOutput{} 1165 out.Result = output 1166 1167 var buff [1024]byte 1168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1169 body := io.TeeReader(response.Body, ringBuffer) 1170 rootDecoder := xml.NewDecoder(body) 1171 t, err := smithyxml.FetchRootElement(rootDecoder) 1172 if err == io.EOF { 1173 return out, metadata, nil 1174 } 1175 if err != nil { 1176 var snapshot bytes.Buffer 1177 io.Copy(&snapshot, ringBuffer) 1178 return out, metadata, &smithy.DeserializationError{ 1179 Err: fmt.Errorf("failed to decode response body, %w", err), 1180 Snapshot: snapshot.Bytes(), 1181 } 1182 } 1183 1184 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1185 t, err = decoder.GetElement("CreateDBClusterSnapshotResult") 1186 if err != nil { 1187 var snapshot bytes.Buffer 1188 io.Copy(&snapshot, ringBuffer) 1189 err = &smithy.DeserializationError{ 1190 Err: fmt.Errorf("failed to decode response body, %w", err), 1191 Snapshot: snapshot.Bytes(), 1192 } 1193 return out, metadata, err 1194 } 1195 1196 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1197 err = awsAwsquery_deserializeOpDocumentCreateDBClusterSnapshotOutput(&output, decoder) 1198 if err != nil { 1199 var snapshot bytes.Buffer 1200 io.Copy(&snapshot, ringBuffer) 1201 err = &smithy.DeserializationError{ 1202 Err: fmt.Errorf("failed to decode response body, %w", err), 1203 Snapshot: snapshot.Bytes(), 1204 } 1205 return out, metadata, err 1206 } 1207 1208 return out, metadata, err 1209} 1210 1211func awsAwsquery_deserializeOpErrorCreateDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1212 var errorBuffer bytes.Buffer 1213 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1214 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1215 } 1216 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1217 1218 errorCode := "UnknownError" 1219 errorMessage := errorCode 1220 1221 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1222 if err != nil { 1223 return err 1224 } 1225 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1226 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1227 } 1228 if len(errorComponents.Code) != 0 { 1229 errorCode = errorComponents.Code 1230 } 1231 if len(errorComponents.Message) != 0 { 1232 errorMessage = errorComponents.Message 1233 } 1234 errorBody.Seek(0, io.SeekStart) 1235 switch { 1236 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1237 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1238 1239 case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): 1240 return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) 1241 1242 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 1243 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 1244 1245 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1246 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1247 1248 case strings.EqualFold("SnapshotQuotaExceeded", errorCode): 1249 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 1250 1251 default: 1252 genericError := &smithy.GenericAPIError{ 1253 Code: errorCode, 1254 Message: errorMessage, 1255 } 1256 return genericError 1257 1258 } 1259} 1260 1261type awsAwsquery_deserializeOpCreateDBInstance struct { 1262} 1263 1264func (*awsAwsquery_deserializeOpCreateDBInstance) ID() string { 1265 return "OperationDeserializer" 1266} 1267 1268func (m *awsAwsquery_deserializeOpCreateDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1269 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1270) { 1271 out, metadata, err = next.HandleDeserialize(ctx, in) 1272 if err != nil { 1273 return out, metadata, err 1274 } 1275 1276 response, ok := out.RawResponse.(*smithyhttp.Response) 1277 if !ok { 1278 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1279 } 1280 1281 if response.StatusCode < 200 || response.StatusCode >= 300 { 1282 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBInstance(response, &metadata) 1283 } 1284 output := &CreateDBInstanceOutput{} 1285 out.Result = output 1286 1287 var buff [1024]byte 1288 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1289 body := io.TeeReader(response.Body, ringBuffer) 1290 rootDecoder := xml.NewDecoder(body) 1291 t, err := smithyxml.FetchRootElement(rootDecoder) 1292 if err == io.EOF { 1293 return out, metadata, nil 1294 } 1295 if err != nil { 1296 var snapshot bytes.Buffer 1297 io.Copy(&snapshot, ringBuffer) 1298 return out, metadata, &smithy.DeserializationError{ 1299 Err: fmt.Errorf("failed to decode response body, %w", err), 1300 Snapshot: snapshot.Bytes(), 1301 } 1302 } 1303 1304 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1305 t, err = decoder.GetElement("CreateDBInstanceResult") 1306 if err != nil { 1307 var snapshot bytes.Buffer 1308 io.Copy(&snapshot, ringBuffer) 1309 err = &smithy.DeserializationError{ 1310 Err: fmt.Errorf("failed to decode response body, %w", err), 1311 Snapshot: snapshot.Bytes(), 1312 } 1313 return out, metadata, err 1314 } 1315 1316 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1317 err = awsAwsquery_deserializeOpDocumentCreateDBInstanceOutput(&output, decoder) 1318 if err != nil { 1319 var snapshot bytes.Buffer 1320 io.Copy(&snapshot, ringBuffer) 1321 err = &smithy.DeserializationError{ 1322 Err: fmt.Errorf("failed to decode response body, %w", err), 1323 Snapshot: snapshot.Bytes(), 1324 } 1325 return out, metadata, err 1326 } 1327 1328 return out, metadata, err 1329} 1330 1331func awsAwsquery_deserializeOpErrorCreateDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1332 var errorBuffer bytes.Buffer 1333 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1334 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1335 } 1336 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1337 1338 errorCode := "UnknownError" 1339 errorMessage := errorCode 1340 1341 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1342 if err != nil { 1343 return err 1344 } 1345 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1346 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1347 } 1348 if len(errorComponents.Code) != 0 { 1349 errorCode = errorComponents.Code 1350 } 1351 if len(errorComponents.Message) != 0 { 1352 errorMessage = errorComponents.Message 1353 } 1354 errorBody.Seek(0, io.SeekStart) 1355 switch { 1356 case strings.EqualFold("AuthorizationNotFound", errorCode): 1357 return awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response, errorBody) 1358 1359 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1360 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1361 1362 case strings.EqualFold("DBInstanceAlreadyExists", errorCode): 1363 return awsAwsquery_deserializeErrorDBInstanceAlreadyExistsFault(response, errorBody) 1364 1365 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 1366 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 1367 1368 case strings.EqualFold("DBSecurityGroupNotFound", errorCode): 1369 return awsAwsquery_deserializeErrorDBSecurityGroupNotFoundFault(response, errorBody) 1370 1371 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 1372 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 1373 1374 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 1375 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 1376 1377 case strings.EqualFold("DomainNotFoundFault", errorCode): 1378 return awsAwsquery_deserializeErrorDomainNotFoundFault(response, errorBody) 1379 1380 case strings.EqualFold("InstanceQuotaExceeded", errorCode): 1381 return awsAwsquery_deserializeErrorInstanceQuotaExceededFault(response, errorBody) 1382 1383 case strings.EqualFold("InsufficientDBInstanceCapacity", errorCode): 1384 return awsAwsquery_deserializeErrorInsufficientDBInstanceCapacityFault(response, errorBody) 1385 1386 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1387 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1388 1389 case strings.EqualFold("InvalidSubnet", errorCode): 1390 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 1391 1392 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 1393 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 1394 1395 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 1396 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 1397 1398 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 1399 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 1400 1401 case strings.EqualFold("ProvisionedIopsNotAvailableInAZFault", errorCode): 1402 return awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response, errorBody) 1403 1404 case strings.EqualFold("StorageQuotaExceeded", errorCode): 1405 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 1406 1407 case strings.EqualFold("StorageTypeNotSupported", errorCode): 1408 return awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response, errorBody) 1409 1410 default: 1411 genericError := &smithy.GenericAPIError{ 1412 Code: errorCode, 1413 Message: errorMessage, 1414 } 1415 return genericError 1416 1417 } 1418} 1419 1420type awsAwsquery_deserializeOpCreateDBParameterGroup struct { 1421} 1422 1423func (*awsAwsquery_deserializeOpCreateDBParameterGroup) ID() string { 1424 return "OperationDeserializer" 1425} 1426 1427func (m *awsAwsquery_deserializeOpCreateDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1428 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1429) { 1430 out, metadata, err = next.HandleDeserialize(ctx, in) 1431 if err != nil { 1432 return out, metadata, err 1433 } 1434 1435 response, ok := out.RawResponse.(*smithyhttp.Response) 1436 if !ok { 1437 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1438 } 1439 1440 if response.StatusCode < 200 || response.StatusCode >= 300 { 1441 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBParameterGroup(response, &metadata) 1442 } 1443 output := &CreateDBParameterGroupOutput{} 1444 out.Result = output 1445 1446 var buff [1024]byte 1447 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1448 body := io.TeeReader(response.Body, ringBuffer) 1449 rootDecoder := xml.NewDecoder(body) 1450 t, err := smithyxml.FetchRootElement(rootDecoder) 1451 if err == io.EOF { 1452 return out, metadata, nil 1453 } 1454 if err != nil { 1455 var snapshot bytes.Buffer 1456 io.Copy(&snapshot, ringBuffer) 1457 return out, metadata, &smithy.DeserializationError{ 1458 Err: fmt.Errorf("failed to decode response body, %w", err), 1459 Snapshot: snapshot.Bytes(), 1460 } 1461 } 1462 1463 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1464 t, err = decoder.GetElement("CreateDBParameterGroupResult") 1465 if err != nil { 1466 var snapshot bytes.Buffer 1467 io.Copy(&snapshot, ringBuffer) 1468 err = &smithy.DeserializationError{ 1469 Err: fmt.Errorf("failed to decode response body, %w", err), 1470 Snapshot: snapshot.Bytes(), 1471 } 1472 return out, metadata, err 1473 } 1474 1475 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1476 err = awsAwsquery_deserializeOpDocumentCreateDBParameterGroupOutput(&output, decoder) 1477 if err != nil { 1478 var snapshot bytes.Buffer 1479 io.Copy(&snapshot, ringBuffer) 1480 err = &smithy.DeserializationError{ 1481 Err: fmt.Errorf("failed to decode response body, %w", err), 1482 Snapshot: snapshot.Bytes(), 1483 } 1484 return out, metadata, err 1485 } 1486 1487 return out, metadata, err 1488} 1489 1490func awsAwsquery_deserializeOpErrorCreateDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1491 var errorBuffer bytes.Buffer 1492 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1493 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1494 } 1495 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1496 1497 errorCode := "UnknownError" 1498 errorMessage := errorCode 1499 1500 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1501 if err != nil { 1502 return err 1503 } 1504 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1505 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1506 } 1507 if len(errorComponents.Code) != 0 { 1508 errorCode = errorComponents.Code 1509 } 1510 if len(errorComponents.Message) != 0 { 1511 errorMessage = errorComponents.Message 1512 } 1513 errorBody.Seek(0, io.SeekStart) 1514 switch { 1515 case strings.EqualFold("DBParameterGroupAlreadyExists", errorCode): 1516 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 1517 1518 case strings.EqualFold("DBParameterGroupQuotaExceeded", errorCode): 1519 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 1520 1521 default: 1522 genericError := &smithy.GenericAPIError{ 1523 Code: errorCode, 1524 Message: errorMessage, 1525 } 1526 return genericError 1527 1528 } 1529} 1530 1531type awsAwsquery_deserializeOpCreateDBSubnetGroup struct { 1532} 1533 1534func (*awsAwsquery_deserializeOpCreateDBSubnetGroup) ID() string { 1535 return "OperationDeserializer" 1536} 1537 1538func (m *awsAwsquery_deserializeOpCreateDBSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1539 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1540) { 1541 out, metadata, err = next.HandleDeserialize(ctx, in) 1542 if err != nil { 1543 return out, metadata, err 1544 } 1545 1546 response, ok := out.RawResponse.(*smithyhttp.Response) 1547 if !ok { 1548 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1549 } 1550 1551 if response.StatusCode < 200 || response.StatusCode >= 300 { 1552 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBSubnetGroup(response, &metadata) 1553 } 1554 output := &CreateDBSubnetGroupOutput{} 1555 out.Result = output 1556 1557 var buff [1024]byte 1558 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1559 body := io.TeeReader(response.Body, ringBuffer) 1560 rootDecoder := xml.NewDecoder(body) 1561 t, err := smithyxml.FetchRootElement(rootDecoder) 1562 if err == io.EOF { 1563 return out, metadata, nil 1564 } 1565 if err != nil { 1566 var snapshot bytes.Buffer 1567 io.Copy(&snapshot, ringBuffer) 1568 return out, metadata, &smithy.DeserializationError{ 1569 Err: fmt.Errorf("failed to decode response body, %w", err), 1570 Snapshot: snapshot.Bytes(), 1571 } 1572 } 1573 1574 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1575 t, err = decoder.GetElement("CreateDBSubnetGroupResult") 1576 if err != nil { 1577 var snapshot bytes.Buffer 1578 io.Copy(&snapshot, ringBuffer) 1579 err = &smithy.DeserializationError{ 1580 Err: fmt.Errorf("failed to decode response body, %w", err), 1581 Snapshot: snapshot.Bytes(), 1582 } 1583 return out, metadata, err 1584 } 1585 1586 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1587 err = awsAwsquery_deserializeOpDocumentCreateDBSubnetGroupOutput(&output, decoder) 1588 if err != nil { 1589 var snapshot bytes.Buffer 1590 io.Copy(&snapshot, ringBuffer) 1591 err = &smithy.DeserializationError{ 1592 Err: fmt.Errorf("failed to decode response body, %w", err), 1593 Snapshot: snapshot.Bytes(), 1594 } 1595 return out, metadata, err 1596 } 1597 1598 return out, metadata, err 1599} 1600 1601func awsAwsquery_deserializeOpErrorCreateDBSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1602 var errorBuffer bytes.Buffer 1603 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1604 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1605 } 1606 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1607 1608 errorCode := "UnknownError" 1609 errorMessage := errorCode 1610 1611 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1612 if err != nil { 1613 return err 1614 } 1615 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1616 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1617 } 1618 if len(errorComponents.Code) != 0 { 1619 errorCode = errorComponents.Code 1620 } 1621 if len(errorComponents.Message) != 0 { 1622 errorMessage = errorComponents.Message 1623 } 1624 errorBody.Seek(0, io.SeekStart) 1625 switch { 1626 case strings.EqualFold("DBSubnetGroupAlreadyExists", errorCode): 1627 return awsAwsquery_deserializeErrorDBSubnetGroupAlreadyExistsFault(response, errorBody) 1628 1629 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 1630 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 1631 1632 case strings.EqualFold("DBSubnetGroupQuotaExceeded", errorCode): 1633 return awsAwsquery_deserializeErrorDBSubnetGroupQuotaExceededFault(response, errorBody) 1634 1635 case strings.EqualFold("DBSubnetQuotaExceededFault", errorCode): 1636 return awsAwsquery_deserializeErrorDBSubnetQuotaExceededFault(response, errorBody) 1637 1638 case strings.EqualFold("InvalidSubnet", errorCode): 1639 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 1640 1641 default: 1642 genericError := &smithy.GenericAPIError{ 1643 Code: errorCode, 1644 Message: errorMessage, 1645 } 1646 return genericError 1647 1648 } 1649} 1650 1651type awsAwsquery_deserializeOpCreateEventSubscription struct { 1652} 1653 1654func (*awsAwsquery_deserializeOpCreateEventSubscription) ID() string { 1655 return "OperationDeserializer" 1656} 1657 1658func (m *awsAwsquery_deserializeOpCreateEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1659 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1660) { 1661 out, metadata, err = next.HandleDeserialize(ctx, in) 1662 if err != nil { 1663 return out, metadata, err 1664 } 1665 1666 response, ok := out.RawResponse.(*smithyhttp.Response) 1667 if !ok { 1668 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1669 } 1670 1671 if response.StatusCode < 200 || response.StatusCode >= 300 { 1672 return out, metadata, awsAwsquery_deserializeOpErrorCreateEventSubscription(response, &metadata) 1673 } 1674 output := &CreateEventSubscriptionOutput{} 1675 out.Result = output 1676 1677 var buff [1024]byte 1678 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1679 body := io.TeeReader(response.Body, ringBuffer) 1680 rootDecoder := xml.NewDecoder(body) 1681 t, err := smithyxml.FetchRootElement(rootDecoder) 1682 if err == io.EOF { 1683 return out, metadata, nil 1684 } 1685 if err != nil { 1686 var snapshot bytes.Buffer 1687 io.Copy(&snapshot, ringBuffer) 1688 return out, metadata, &smithy.DeserializationError{ 1689 Err: fmt.Errorf("failed to decode response body, %w", err), 1690 Snapshot: snapshot.Bytes(), 1691 } 1692 } 1693 1694 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1695 t, err = decoder.GetElement("CreateEventSubscriptionResult") 1696 if err != nil { 1697 var snapshot bytes.Buffer 1698 io.Copy(&snapshot, ringBuffer) 1699 err = &smithy.DeserializationError{ 1700 Err: fmt.Errorf("failed to decode response body, %w", err), 1701 Snapshot: snapshot.Bytes(), 1702 } 1703 return out, metadata, err 1704 } 1705 1706 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1707 err = awsAwsquery_deserializeOpDocumentCreateEventSubscriptionOutput(&output, decoder) 1708 if err != nil { 1709 var snapshot bytes.Buffer 1710 io.Copy(&snapshot, ringBuffer) 1711 err = &smithy.DeserializationError{ 1712 Err: fmt.Errorf("failed to decode response body, %w", err), 1713 Snapshot: snapshot.Bytes(), 1714 } 1715 return out, metadata, err 1716 } 1717 1718 return out, metadata, err 1719} 1720 1721func awsAwsquery_deserializeOpErrorCreateEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1722 var errorBuffer bytes.Buffer 1723 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1724 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1725 } 1726 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1727 1728 errorCode := "UnknownError" 1729 errorMessage := errorCode 1730 1731 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1732 if err != nil { 1733 return err 1734 } 1735 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1736 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1737 } 1738 if len(errorComponents.Code) != 0 { 1739 errorCode = errorComponents.Code 1740 } 1741 if len(errorComponents.Message) != 0 { 1742 errorMessage = errorComponents.Message 1743 } 1744 errorBody.Seek(0, io.SeekStart) 1745 switch { 1746 case strings.EqualFold("EventSubscriptionQuotaExceeded", errorCode): 1747 return awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response, errorBody) 1748 1749 case strings.EqualFold("SNSInvalidTopic", errorCode): 1750 return awsAwsquery_deserializeErrorSNSInvalidTopicFault(response, errorBody) 1751 1752 case strings.EqualFold("SNSNoAuthorization", errorCode): 1753 return awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response, errorBody) 1754 1755 case strings.EqualFold("SNSTopicArnNotFound", errorCode): 1756 return awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response, errorBody) 1757 1758 case strings.EqualFold("SourceNotFound", errorCode): 1759 return awsAwsquery_deserializeErrorSourceNotFoundFault(response, errorBody) 1760 1761 case strings.EqualFold("SubscriptionAlreadyExist", errorCode): 1762 return awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response, errorBody) 1763 1764 case strings.EqualFold("SubscriptionCategoryNotFound", errorCode): 1765 return awsAwsquery_deserializeErrorSubscriptionCategoryNotFoundFault(response, errorBody) 1766 1767 default: 1768 genericError := &smithy.GenericAPIError{ 1769 Code: errorCode, 1770 Message: errorMessage, 1771 } 1772 return genericError 1773 1774 } 1775} 1776 1777type awsAwsquery_deserializeOpDeleteDBCluster struct { 1778} 1779 1780func (*awsAwsquery_deserializeOpDeleteDBCluster) ID() string { 1781 return "OperationDeserializer" 1782} 1783 1784func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1785 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1786) { 1787 out, metadata, err = next.HandleDeserialize(ctx, in) 1788 if err != nil { 1789 return out, metadata, err 1790 } 1791 1792 response, ok := out.RawResponse.(*smithyhttp.Response) 1793 if !ok { 1794 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1795 } 1796 1797 if response.StatusCode < 200 || response.StatusCode >= 300 { 1798 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBCluster(response, &metadata) 1799 } 1800 output := &DeleteDBClusterOutput{} 1801 out.Result = output 1802 1803 var buff [1024]byte 1804 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1805 body := io.TeeReader(response.Body, ringBuffer) 1806 rootDecoder := xml.NewDecoder(body) 1807 t, err := smithyxml.FetchRootElement(rootDecoder) 1808 if err == io.EOF { 1809 return out, metadata, nil 1810 } 1811 if err != nil { 1812 var snapshot bytes.Buffer 1813 io.Copy(&snapshot, ringBuffer) 1814 return out, metadata, &smithy.DeserializationError{ 1815 Err: fmt.Errorf("failed to decode response body, %w", err), 1816 Snapshot: snapshot.Bytes(), 1817 } 1818 } 1819 1820 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1821 t, err = decoder.GetElement("DeleteDBClusterResult") 1822 if err != nil { 1823 var snapshot bytes.Buffer 1824 io.Copy(&snapshot, ringBuffer) 1825 err = &smithy.DeserializationError{ 1826 Err: fmt.Errorf("failed to decode response body, %w", err), 1827 Snapshot: snapshot.Bytes(), 1828 } 1829 return out, metadata, err 1830 } 1831 1832 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1833 err = awsAwsquery_deserializeOpDocumentDeleteDBClusterOutput(&output, decoder) 1834 if err != nil { 1835 var snapshot bytes.Buffer 1836 io.Copy(&snapshot, ringBuffer) 1837 err = &smithy.DeserializationError{ 1838 Err: fmt.Errorf("failed to decode response body, %w", err), 1839 Snapshot: snapshot.Bytes(), 1840 } 1841 return out, metadata, err 1842 } 1843 1844 return out, metadata, err 1845} 1846 1847func awsAwsquery_deserializeOpErrorDeleteDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1848 var errorBuffer bytes.Buffer 1849 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1850 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1851 } 1852 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1853 1854 errorCode := "UnknownError" 1855 errorMessage := errorCode 1856 1857 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1858 if err != nil { 1859 return err 1860 } 1861 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1862 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1863 } 1864 if len(errorComponents.Code) != 0 { 1865 errorCode = errorComponents.Code 1866 } 1867 if len(errorComponents.Message) != 0 { 1868 errorMessage = errorComponents.Message 1869 } 1870 errorBody.Seek(0, io.SeekStart) 1871 switch { 1872 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1873 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1874 1875 case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): 1876 return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) 1877 1878 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 1879 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 1880 1881 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1882 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1883 1884 case strings.EqualFold("SnapshotQuotaExceeded", errorCode): 1885 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 1886 1887 default: 1888 genericError := &smithy.GenericAPIError{ 1889 Code: errorCode, 1890 Message: errorMessage, 1891 } 1892 return genericError 1893 1894 } 1895} 1896 1897type awsAwsquery_deserializeOpDeleteDBClusterEndpoint struct { 1898} 1899 1900func (*awsAwsquery_deserializeOpDeleteDBClusterEndpoint) ID() string { 1901 return "OperationDeserializer" 1902} 1903 1904func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1905 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1906) { 1907 out, metadata, err = next.HandleDeserialize(ctx, in) 1908 if err != nil { 1909 return out, metadata, err 1910 } 1911 1912 response, ok := out.RawResponse.(*smithyhttp.Response) 1913 if !ok { 1914 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1915 } 1916 1917 if response.StatusCode < 200 || response.StatusCode >= 300 { 1918 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response, &metadata) 1919 } 1920 output := &DeleteDBClusterEndpointOutput{} 1921 out.Result = output 1922 1923 var buff [1024]byte 1924 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1925 body := io.TeeReader(response.Body, ringBuffer) 1926 rootDecoder := xml.NewDecoder(body) 1927 t, err := smithyxml.FetchRootElement(rootDecoder) 1928 if err == io.EOF { 1929 return out, metadata, nil 1930 } 1931 if err != nil { 1932 var snapshot bytes.Buffer 1933 io.Copy(&snapshot, ringBuffer) 1934 return out, metadata, &smithy.DeserializationError{ 1935 Err: fmt.Errorf("failed to decode response body, %w", err), 1936 Snapshot: snapshot.Bytes(), 1937 } 1938 } 1939 1940 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1941 t, err = decoder.GetElement("DeleteDBClusterEndpointResult") 1942 if err != nil { 1943 var snapshot bytes.Buffer 1944 io.Copy(&snapshot, ringBuffer) 1945 err = &smithy.DeserializationError{ 1946 Err: fmt.Errorf("failed to decode response body, %w", err), 1947 Snapshot: snapshot.Bytes(), 1948 } 1949 return out, metadata, err 1950 } 1951 1952 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1953 err = awsAwsquery_deserializeOpDocumentDeleteDBClusterEndpointOutput(&output, decoder) 1954 if err != nil { 1955 var snapshot bytes.Buffer 1956 io.Copy(&snapshot, ringBuffer) 1957 err = &smithy.DeserializationError{ 1958 Err: fmt.Errorf("failed to decode response body, %w", err), 1959 Snapshot: snapshot.Bytes(), 1960 } 1961 return out, metadata, err 1962 } 1963 1964 return out, metadata, err 1965} 1966 1967func awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1968 var errorBuffer bytes.Buffer 1969 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1970 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1971 } 1972 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1973 1974 errorCode := "UnknownError" 1975 errorMessage := errorCode 1976 1977 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1978 if err != nil { 1979 return err 1980 } 1981 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1982 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1983 } 1984 if len(errorComponents.Code) != 0 { 1985 errorCode = errorComponents.Code 1986 } 1987 if len(errorComponents.Message) != 0 { 1988 errorMessage = errorComponents.Message 1989 } 1990 errorBody.Seek(0, io.SeekStart) 1991 switch { 1992 case strings.EqualFold("DBClusterEndpointNotFoundFault", errorCode): 1993 return awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response, errorBody) 1994 1995 case strings.EqualFold("InvalidDBClusterEndpointStateFault", errorCode): 1996 return awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response, errorBody) 1997 1998 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1999 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 2000 2001 default: 2002 genericError := &smithy.GenericAPIError{ 2003 Code: errorCode, 2004 Message: errorMessage, 2005 } 2006 return genericError 2007 2008 } 2009} 2010 2011type awsAwsquery_deserializeOpDeleteDBClusterParameterGroup struct { 2012} 2013 2014func (*awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) ID() string { 2015 return "OperationDeserializer" 2016} 2017 2018func (m *awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2019 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2020) { 2021 out, metadata, err = next.HandleDeserialize(ctx, in) 2022 if err != nil { 2023 return out, metadata, err 2024 } 2025 2026 response, ok := out.RawResponse.(*smithyhttp.Response) 2027 if !ok { 2028 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2029 } 2030 2031 if response.StatusCode < 200 || response.StatusCode >= 300 { 2032 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response, &metadata) 2033 } 2034 output := &DeleteDBClusterParameterGroupOutput{} 2035 out.Result = output 2036 2037 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2038 return out, metadata, &smithy.DeserializationError{ 2039 Err: fmt.Errorf("failed to discard response body, %w", err), 2040 } 2041 } 2042 2043 return out, metadata, err 2044} 2045 2046func awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2047 var errorBuffer bytes.Buffer 2048 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2049 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2050 } 2051 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2052 2053 errorCode := "UnknownError" 2054 errorMessage := errorCode 2055 2056 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2057 if err != nil { 2058 return err 2059 } 2060 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2061 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2062 } 2063 if len(errorComponents.Code) != 0 { 2064 errorCode = errorComponents.Code 2065 } 2066 if len(errorComponents.Message) != 0 { 2067 errorMessage = errorComponents.Message 2068 } 2069 errorBody.Seek(0, io.SeekStart) 2070 switch { 2071 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 2072 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2073 2074 case strings.EqualFold("InvalidDBParameterGroupState", errorCode): 2075 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 2076 2077 default: 2078 genericError := &smithy.GenericAPIError{ 2079 Code: errorCode, 2080 Message: errorMessage, 2081 } 2082 return genericError 2083 2084 } 2085} 2086 2087type awsAwsquery_deserializeOpDeleteDBClusterSnapshot struct { 2088} 2089 2090func (*awsAwsquery_deserializeOpDeleteDBClusterSnapshot) ID() string { 2091 return "OperationDeserializer" 2092} 2093 2094func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2095 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2096) { 2097 out, metadata, err = next.HandleDeserialize(ctx, in) 2098 if err != nil { 2099 return out, metadata, err 2100 } 2101 2102 response, ok := out.RawResponse.(*smithyhttp.Response) 2103 if !ok { 2104 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2105 } 2106 2107 if response.StatusCode < 200 || response.StatusCode >= 300 { 2108 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response, &metadata) 2109 } 2110 output := &DeleteDBClusterSnapshotOutput{} 2111 out.Result = output 2112 2113 var buff [1024]byte 2114 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2115 body := io.TeeReader(response.Body, ringBuffer) 2116 rootDecoder := xml.NewDecoder(body) 2117 t, err := smithyxml.FetchRootElement(rootDecoder) 2118 if err == io.EOF { 2119 return out, metadata, nil 2120 } 2121 if err != nil { 2122 var snapshot bytes.Buffer 2123 io.Copy(&snapshot, ringBuffer) 2124 return out, metadata, &smithy.DeserializationError{ 2125 Err: fmt.Errorf("failed to decode response body, %w", err), 2126 Snapshot: snapshot.Bytes(), 2127 } 2128 } 2129 2130 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2131 t, err = decoder.GetElement("DeleteDBClusterSnapshotResult") 2132 if err != nil { 2133 var snapshot bytes.Buffer 2134 io.Copy(&snapshot, ringBuffer) 2135 err = &smithy.DeserializationError{ 2136 Err: fmt.Errorf("failed to decode response body, %w", err), 2137 Snapshot: snapshot.Bytes(), 2138 } 2139 return out, metadata, err 2140 } 2141 2142 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2143 err = awsAwsquery_deserializeOpDocumentDeleteDBClusterSnapshotOutput(&output, decoder) 2144 if err != nil { 2145 var snapshot bytes.Buffer 2146 io.Copy(&snapshot, ringBuffer) 2147 err = &smithy.DeserializationError{ 2148 Err: fmt.Errorf("failed to decode response body, %w", err), 2149 Snapshot: snapshot.Bytes(), 2150 } 2151 return out, metadata, err 2152 } 2153 2154 return out, metadata, err 2155} 2156 2157func awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2158 var errorBuffer bytes.Buffer 2159 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2160 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2161 } 2162 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2163 2164 errorCode := "UnknownError" 2165 errorMessage := errorCode 2166 2167 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2168 if err != nil { 2169 return err 2170 } 2171 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2172 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2173 } 2174 if len(errorComponents.Code) != 0 { 2175 errorCode = errorComponents.Code 2176 } 2177 if len(errorComponents.Message) != 0 { 2178 errorMessage = errorComponents.Message 2179 } 2180 errorBody.Seek(0, io.SeekStart) 2181 switch { 2182 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 2183 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 2184 2185 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 2186 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 2187 2188 default: 2189 genericError := &smithy.GenericAPIError{ 2190 Code: errorCode, 2191 Message: errorMessage, 2192 } 2193 return genericError 2194 2195 } 2196} 2197 2198type awsAwsquery_deserializeOpDeleteDBInstance struct { 2199} 2200 2201func (*awsAwsquery_deserializeOpDeleteDBInstance) ID() string { 2202 return "OperationDeserializer" 2203} 2204 2205func (m *awsAwsquery_deserializeOpDeleteDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2206 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2207) { 2208 out, metadata, err = next.HandleDeserialize(ctx, in) 2209 if err != nil { 2210 return out, metadata, err 2211 } 2212 2213 response, ok := out.RawResponse.(*smithyhttp.Response) 2214 if !ok { 2215 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2216 } 2217 2218 if response.StatusCode < 200 || response.StatusCode >= 300 { 2219 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBInstance(response, &metadata) 2220 } 2221 output := &DeleteDBInstanceOutput{} 2222 out.Result = output 2223 2224 var buff [1024]byte 2225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2226 body := io.TeeReader(response.Body, ringBuffer) 2227 rootDecoder := xml.NewDecoder(body) 2228 t, err := smithyxml.FetchRootElement(rootDecoder) 2229 if err == io.EOF { 2230 return out, metadata, nil 2231 } 2232 if err != nil { 2233 var snapshot bytes.Buffer 2234 io.Copy(&snapshot, ringBuffer) 2235 return out, metadata, &smithy.DeserializationError{ 2236 Err: fmt.Errorf("failed to decode response body, %w", err), 2237 Snapshot: snapshot.Bytes(), 2238 } 2239 } 2240 2241 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2242 t, err = decoder.GetElement("DeleteDBInstanceResult") 2243 if err != nil { 2244 var snapshot bytes.Buffer 2245 io.Copy(&snapshot, ringBuffer) 2246 err = &smithy.DeserializationError{ 2247 Err: fmt.Errorf("failed to decode response body, %w", err), 2248 Snapshot: snapshot.Bytes(), 2249 } 2250 return out, metadata, err 2251 } 2252 2253 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2254 err = awsAwsquery_deserializeOpDocumentDeleteDBInstanceOutput(&output, decoder) 2255 if err != nil { 2256 var snapshot bytes.Buffer 2257 io.Copy(&snapshot, ringBuffer) 2258 err = &smithy.DeserializationError{ 2259 Err: fmt.Errorf("failed to decode response body, %w", err), 2260 Snapshot: snapshot.Bytes(), 2261 } 2262 return out, metadata, err 2263 } 2264 2265 return out, metadata, err 2266} 2267 2268func awsAwsquery_deserializeOpErrorDeleteDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2269 var errorBuffer bytes.Buffer 2270 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2271 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2272 } 2273 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2274 2275 errorCode := "UnknownError" 2276 errorMessage := errorCode 2277 2278 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2279 if err != nil { 2280 return err 2281 } 2282 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2283 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2284 } 2285 if len(errorComponents.Code) != 0 { 2286 errorCode = errorComponents.Code 2287 } 2288 if len(errorComponents.Message) != 0 { 2289 errorMessage = errorComponents.Message 2290 } 2291 errorBody.Seek(0, io.SeekStart) 2292 switch { 2293 case strings.EqualFold("DBInstanceNotFound", errorCode): 2294 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 2295 2296 case strings.EqualFold("DBSnapshotAlreadyExists", errorCode): 2297 return awsAwsquery_deserializeErrorDBSnapshotAlreadyExistsFault(response, errorBody) 2298 2299 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 2300 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 2301 2302 case strings.EqualFold("InvalidDBInstanceState", errorCode): 2303 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 2304 2305 case strings.EqualFold("SnapshotQuotaExceeded", errorCode): 2306 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 2307 2308 default: 2309 genericError := &smithy.GenericAPIError{ 2310 Code: errorCode, 2311 Message: errorMessage, 2312 } 2313 return genericError 2314 2315 } 2316} 2317 2318type awsAwsquery_deserializeOpDeleteDBParameterGroup struct { 2319} 2320 2321func (*awsAwsquery_deserializeOpDeleteDBParameterGroup) ID() string { 2322 return "OperationDeserializer" 2323} 2324 2325func (m *awsAwsquery_deserializeOpDeleteDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2326 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2327) { 2328 out, metadata, err = next.HandleDeserialize(ctx, in) 2329 if err != nil { 2330 return out, metadata, err 2331 } 2332 2333 response, ok := out.RawResponse.(*smithyhttp.Response) 2334 if !ok { 2335 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2336 } 2337 2338 if response.StatusCode < 200 || response.StatusCode >= 300 { 2339 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBParameterGroup(response, &metadata) 2340 } 2341 output := &DeleteDBParameterGroupOutput{} 2342 out.Result = output 2343 2344 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2345 return out, metadata, &smithy.DeserializationError{ 2346 Err: fmt.Errorf("failed to discard response body, %w", err), 2347 } 2348 } 2349 2350 return out, metadata, err 2351} 2352 2353func awsAwsquery_deserializeOpErrorDeleteDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2354 var errorBuffer bytes.Buffer 2355 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2356 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2357 } 2358 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2359 2360 errorCode := "UnknownError" 2361 errorMessage := errorCode 2362 2363 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2364 if err != nil { 2365 return err 2366 } 2367 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2368 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2369 } 2370 if len(errorComponents.Code) != 0 { 2371 errorCode = errorComponents.Code 2372 } 2373 if len(errorComponents.Message) != 0 { 2374 errorMessage = errorComponents.Message 2375 } 2376 errorBody.Seek(0, io.SeekStart) 2377 switch { 2378 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 2379 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2380 2381 case strings.EqualFold("InvalidDBParameterGroupState", errorCode): 2382 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 2383 2384 default: 2385 genericError := &smithy.GenericAPIError{ 2386 Code: errorCode, 2387 Message: errorMessage, 2388 } 2389 return genericError 2390 2391 } 2392} 2393 2394type awsAwsquery_deserializeOpDeleteDBSubnetGroup struct { 2395} 2396 2397func (*awsAwsquery_deserializeOpDeleteDBSubnetGroup) ID() string { 2398 return "OperationDeserializer" 2399} 2400 2401func (m *awsAwsquery_deserializeOpDeleteDBSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2402 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2403) { 2404 out, metadata, err = next.HandleDeserialize(ctx, in) 2405 if err != nil { 2406 return out, metadata, err 2407 } 2408 2409 response, ok := out.RawResponse.(*smithyhttp.Response) 2410 if !ok { 2411 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2412 } 2413 2414 if response.StatusCode < 200 || response.StatusCode >= 300 { 2415 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBSubnetGroup(response, &metadata) 2416 } 2417 output := &DeleteDBSubnetGroupOutput{} 2418 out.Result = output 2419 2420 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2421 return out, metadata, &smithy.DeserializationError{ 2422 Err: fmt.Errorf("failed to discard response body, %w", err), 2423 } 2424 } 2425 2426 return out, metadata, err 2427} 2428 2429func awsAwsquery_deserializeOpErrorDeleteDBSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2430 var errorBuffer bytes.Buffer 2431 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2432 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2433 } 2434 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2435 2436 errorCode := "UnknownError" 2437 errorMessage := errorCode 2438 2439 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2440 if err != nil { 2441 return err 2442 } 2443 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2444 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2445 } 2446 if len(errorComponents.Code) != 0 { 2447 errorCode = errorComponents.Code 2448 } 2449 if len(errorComponents.Message) != 0 { 2450 errorMessage = errorComponents.Message 2451 } 2452 errorBody.Seek(0, io.SeekStart) 2453 switch { 2454 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 2455 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 2456 2457 case strings.EqualFold("InvalidDBSubnetGroupStateFault", errorCode): 2458 return awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response, errorBody) 2459 2460 case strings.EqualFold("InvalidDBSubnetStateFault", errorCode): 2461 return awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response, errorBody) 2462 2463 default: 2464 genericError := &smithy.GenericAPIError{ 2465 Code: errorCode, 2466 Message: errorMessage, 2467 } 2468 return genericError 2469 2470 } 2471} 2472 2473type awsAwsquery_deserializeOpDeleteEventSubscription struct { 2474} 2475 2476func (*awsAwsquery_deserializeOpDeleteEventSubscription) ID() string { 2477 return "OperationDeserializer" 2478} 2479 2480func (m *awsAwsquery_deserializeOpDeleteEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2481 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2482) { 2483 out, metadata, err = next.HandleDeserialize(ctx, in) 2484 if err != nil { 2485 return out, metadata, err 2486 } 2487 2488 response, ok := out.RawResponse.(*smithyhttp.Response) 2489 if !ok { 2490 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2491 } 2492 2493 if response.StatusCode < 200 || response.StatusCode >= 300 { 2494 return out, metadata, awsAwsquery_deserializeOpErrorDeleteEventSubscription(response, &metadata) 2495 } 2496 output := &DeleteEventSubscriptionOutput{} 2497 out.Result = output 2498 2499 var buff [1024]byte 2500 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2501 body := io.TeeReader(response.Body, ringBuffer) 2502 rootDecoder := xml.NewDecoder(body) 2503 t, err := smithyxml.FetchRootElement(rootDecoder) 2504 if err == io.EOF { 2505 return out, metadata, nil 2506 } 2507 if err != nil { 2508 var snapshot bytes.Buffer 2509 io.Copy(&snapshot, ringBuffer) 2510 return out, metadata, &smithy.DeserializationError{ 2511 Err: fmt.Errorf("failed to decode response body, %w", err), 2512 Snapshot: snapshot.Bytes(), 2513 } 2514 } 2515 2516 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2517 t, err = decoder.GetElement("DeleteEventSubscriptionResult") 2518 if err != nil { 2519 var snapshot bytes.Buffer 2520 io.Copy(&snapshot, ringBuffer) 2521 err = &smithy.DeserializationError{ 2522 Err: fmt.Errorf("failed to decode response body, %w", err), 2523 Snapshot: snapshot.Bytes(), 2524 } 2525 return out, metadata, err 2526 } 2527 2528 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2529 err = awsAwsquery_deserializeOpDocumentDeleteEventSubscriptionOutput(&output, decoder) 2530 if err != nil { 2531 var snapshot bytes.Buffer 2532 io.Copy(&snapshot, ringBuffer) 2533 err = &smithy.DeserializationError{ 2534 Err: fmt.Errorf("failed to decode response body, %w", err), 2535 Snapshot: snapshot.Bytes(), 2536 } 2537 return out, metadata, err 2538 } 2539 2540 return out, metadata, err 2541} 2542 2543func awsAwsquery_deserializeOpErrorDeleteEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2544 var errorBuffer bytes.Buffer 2545 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2546 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2547 } 2548 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2549 2550 errorCode := "UnknownError" 2551 errorMessage := errorCode 2552 2553 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2554 if err != nil { 2555 return err 2556 } 2557 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2558 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2559 } 2560 if len(errorComponents.Code) != 0 { 2561 errorCode = errorComponents.Code 2562 } 2563 if len(errorComponents.Message) != 0 { 2564 errorMessage = errorComponents.Message 2565 } 2566 errorBody.Seek(0, io.SeekStart) 2567 switch { 2568 case strings.EqualFold("InvalidEventSubscriptionState", errorCode): 2569 return awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response, errorBody) 2570 2571 case strings.EqualFold("SubscriptionNotFound", errorCode): 2572 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 2573 2574 default: 2575 genericError := &smithy.GenericAPIError{ 2576 Code: errorCode, 2577 Message: errorMessage, 2578 } 2579 return genericError 2580 2581 } 2582} 2583 2584type awsAwsquery_deserializeOpDescribeDBClusterEndpoints struct { 2585} 2586 2587func (*awsAwsquery_deserializeOpDescribeDBClusterEndpoints) ID() string { 2588 return "OperationDeserializer" 2589} 2590 2591func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2592 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2593) { 2594 out, metadata, err = next.HandleDeserialize(ctx, in) 2595 if err != nil { 2596 return out, metadata, err 2597 } 2598 2599 response, ok := out.RawResponse.(*smithyhttp.Response) 2600 if !ok { 2601 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2602 } 2603 2604 if response.StatusCode < 200 || response.StatusCode >= 300 { 2605 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response, &metadata) 2606 } 2607 output := &DescribeDBClusterEndpointsOutput{} 2608 out.Result = output 2609 2610 var buff [1024]byte 2611 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2612 body := io.TeeReader(response.Body, ringBuffer) 2613 rootDecoder := xml.NewDecoder(body) 2614 t, err := smithyxml.FetchRootElement(rootDecoder) 2615 if err == io.EOF { 2616 return out, metadata, nil 2617 } 2618 if err != nil { 2619 var snapshot bytes.Buffer 2620 io.Copy(&snapshot, ringBuffer) 2621 return out, metadata, &smithy.DeserializationError{ 2622 Err: fmt.Errorf("failed to decode response body, %w", err), 2623 Snapshot: snapshot.Bytes(), 2624 } 2625 } 2626 2627 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2628 t, err = decoder.GetElement("DescribeDBClusterEndpointsResult") 2629 if err != nil { 2630 var snapshot bytes.Buffer 2631 io.Copy(&snapshot, ringBuffer) 2632 err = &smithy.DeserializationError{ 2633 Err: fmt.Errorf("failed to decode response body, %w", err), 2634 Snapshot: snapshot.Bytes(), 2635 } 2636 return out, metadata, err 2637 } 2638 2639 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2640 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(&output, decoder) 2641 if err != nil { 2642 var snapshot bytes.Buffer 2643 io.Copy(&snapshot, ringBuffer) 2644 err = &smithy.DeserializationError{ 2645 Err: fmt.Errorf("failed to decode response body, %w", err), 2646 Snapshot: snapshot.Bytes(), 2647 } 2648 return out, metadata, err 2649 } 2650 2651 return out, metadata, err 2652} 2653 2654func awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2655 var errorBuffer bytes.Buffer 2656 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2657 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2658 } 2659 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2660 2661 errorCode := "UnknownError" 2662 errorMessage := errorCode 2663 2664 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2665 if err != nil { 2666 return err 2667 } 2668 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2669 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2670 } 2671 if len(errorComponents.Code) != 0 { 2672 errorCode = errorComponents.Code 2673 } 2674 if len(errorComponents.Message) != 0 { 2675 errorMessage = errorComponents.Message 2676 } 2677 errorBody.Seek(0, io.SeekStart) 2678 switch { 2679 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 2680 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 2681 2682 default: 2683 genericError := &smithy.GenericAPIError{ 2684 Code: errorCode, 2685 Message: errorMessage, 2686 } 2687 return genericError 2688 2689 } 2690} 2691 2692type awsAwsquery_deserializeOpDescribeDBClusterParameterGroups struct { 2693} 2694 2695func (*awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) ID() string { 2696 return "OperationDeserializer" 2697} 2698 2699func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2700 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2701) { 2702 out, metadata, err = next.HandleDeserialize(ctx, in) 2703 if err != nil { 2704 return out, metadata, err 2705 } 2706 2707 response, ok := out.RawResponse.(*smithyhttp.Response) 2708 if !ok { 2709 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2710 } 2711 2712 if response.StatusCode < 200 || response.StatusCode >= 300 { 2713 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response, &metadata) 2714 } 2715 output := &DescribeDBClusterParameterGroupsOutput{} 2716 out.Result = output 2717 2718 var buff [1024]byte 2719 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2720 body := io.TeeReader(response.Body, ringBuffer) 2721 rootDecoder := xml.NewDecoder(body) 2722 t, err := smithyxml.FetchRootElement(rootDecoder) 2723 if err == io.EOF { 2724 return out, metadata, nil 2725 } 2726 if err != nil { 2727 var snapshot bytes.Buffer 2728 io.Copy(&snapshot, ringBuffer) 2729 return out, metadata, &smithy.DeserializationError{ 2730 Err: fmt.Errorf("failed to decode response body, %w", err), 2731 Snapshot: snapshot.Bytes(), 2732 } 2733 } 2734 2735 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2736 t, err = decoder.GetElement("DescribeDBClusterParameterGroupsResult") 2737 if err != nil { 2738 var snapshot bytes.Buffer 2739 io.Copy(&snapshot, ringBuffer) 2740 err = &smithy.DeserializationError{ 2741 Err: fmt.Errorf("failed to decode response body, %w", err), 2742 Snapshot: snapshot.Bytes(), 2743 } 2744 return out, metadata, err 2745 } 2746 2747 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2748 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(&output, decoder) 2749 if err != nil { 2750 var snapshot bytes.Buffer 2751 io.Copy(&snapshot, ringBuffer) 2752 err = &smithy.DeserializationError{ 2753 Err: fmt.Errorf("failed to decode response body, %w", err), 2754 Snapshot: snapshot.Bytes(), 2755 } 2756 return out, metadata, err 2757 } 2758 2759 return out, metadata, err 2760} 2761 2762func awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2763 var errorBuffer bytes.Buffer 2764 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2765 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2766 } 2767 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2768 2769 errorCode := "UnknownError" 2770 errorMessage := errorCode 2771 2772 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2773 if err != nil { 2774 return err 2775 } 2776 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2777 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2778 } 2779 if len(errorComponents.Code) != 0 { 2780 errorCode = errorComponents.Code 2781 } 2782 if len(errorComponents.Message) != 0 { 2783 errorMessage = errorComponents.Message 2784 } 2785 errorBody.Seek(0, io.SeekStart) 2786 switch { 2787 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 2788 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2789 2790 default: 2791 genericError := &smithy.GenericAPIError{ 2792 Code: errorCode, 2793 Message: errorMessage, 2794 } 2795 return genericError 2796 2797 } 2798} 2799 2800type awsAwsquery_deserializeOpDescribeDBClusterParameters struct { 2801} 2802 2803func (*awsAwsquery_deserializeOpDescribeDBClusterParameters) ID() string { 2804 return "OperationDeserializer" 2805} 2806 2807func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2808 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2809) { 2810 out, metadata, err = next.HandleDeserialize(ctx, in) 2811 if err != nil { 2812 return out, metadata, err 2813 } 2814 2815 response, ok := out.RawResponse.(*smithyhttp.Response) 2816 if !ok { 2817 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2818 } 2819 2820 if response.StatusCode < 200 || response.StatusCode >= 300 { 2821 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response, &metadata) 2822 } 2823 output := &DescribeDBClusterParametersOutput{} 2824 out.Result = output 2825 2826 var buff [1024]byte 2827 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2828 body := io.TeeReader(response.Body, ringBuffer) 2829 rootDecoder := xml.NewDecoder(body) 2830 t, err := smithyxml.FetchRootElement(rootDecoder) 2831 if err == io.EOF { 2832 return out, metadata, nil 2833 } 2834 if err != nil { 2835 var snapshot bytes.Buffer 2836 io.Copy(&snapshot, ringBuffer) 2837 return out, metadata, &smithy.DeserializationError{ 2838 Err: fmt.Errorf("failed to decode response body, %w", err), 2839 Snapshot: snapshot.Bytes(), 2840 } 2841 } 2842 2843 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2844 t, err = decoder.GetElement("DescribeDBClusterParametersResult") 2845 if err != nil { 2846 var snapshot bytes.Buffer 2847 io.Copy(&snapshot, ringBuffer) 2848 err = &smithy.DeserializationError{ 2849 Err: fmt.Errorf("failed to decode response body, %w", err), 2850 Snapshot: snapshot.Bytes(), 2851 } 2852 return out, metadata, err 2853 } 2854 2855 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2856 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(&output, decoder) 2857 if err != nil { 2858 var snapshot bytes.Buffer 2859 io.Copy(&snapshot, ringBuffer) 2860 err = &smithy.DeserializationError{ 2861 Err: fmt.Errorf("failed to decode response body, %w", err), 2862 Snapshot: snapshot.Bytes(), 2863 } 2864 return out, metadata, err 2865 } 2866 2867 return out, metadata, err 2868} 2869 2870func awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2871 var errorBuffer bytes.Buffer 2872 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2873 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2874 } 2875 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2876 2877 errorCode := "UnknownError" 2878 errorMessage := errorCode 2879 2880 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2881 if err != nil { 2882 return err 2883 } 2884 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2885 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2886 } 2887 if len(errorComponents.Code) != 0 { 2888 errorCode = errorComponents.Code 2889 } 2890 if len(errorComponents.Message) != 0 { 2891 errorMessage = errorComponents.Message 2892 } 2893 errorBody.Seek(0, io.SeekStart) 2894 switch { 2895 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 2896 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2897 2898 default: 2899 genericError := &smithy.GenericAPIError{ 2900 Code: errorCode, 2901 Message: errorMessage, 2902 } 2903 return genericError 2904 2905 } 2906} 2907 2908type awsAwsquery_deserializeOpDescribeDBClusters struct { 2909} 2910 2911func (*awsAwsquery_deserializeOpDescribeDBClusters) ID() string { 2912 return "OperationDeserializer" 2913} 2914 2915func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2916 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2917) { 2918 out, metadata, err = next.HandleDeserialize(ctx, in) 2919 if err != nil { 2920 return out, metadata, err 2921 } 2922 2923 response, ok := out.RawResponse.(*smithyhttp.Response) 2924 if !ok { 2925 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2926 } 2927 2928 if response.StatusCode < 200 || response.StatusCode >= 300 { 2929 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusters(response, &metadata) 2930 } 2931 output := &DescribeDBClustersOutput{} 2932 out.Result = output 2933 2934 var buff [1024]byte 2935 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2936 body := io.TeeReader(response.Body, ringBuffer) 2937 rootDecoder := xml.NewDecoder(body) 2938 t, err := smithyxml.FetchRootElement(rootDecoder) 2939 if err == io.EOF { 2940 return out, metadata, nil 2941 } 2942 if err != nil { 2943 var snapshot bytes.Buffer 2944 io.Copy(&snapshot, ringBuffer) 2945 return out, metadata, &smithy.DeserializationError{ 2946 Err: fmt.Errorf("failed to decode response body, %w", err), 2947 Snapshot: snapshot.Bytes(), 2948 } 2949 } 2950 2951 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2952 t, err = decoder.GetElement("DescribeDBClustersResult") 2953 if err != nil { 2954 var snapshot bytes.Buffer 2955 io.Copy(&snapshot, ringBuffer) 2956 err = &smithy.DeserializationError{ 2957 Err: fmt.Errorf("failed to decode response body, %w", err), 2958 Snapshot: snapshot.Bytes(), 2959 } 2960 return out, metadata, err 2961 } 2962 2963 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2964 err = awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(&output, decoder) 2965 if err != nil { 2966 var snapshot bytes.Buffer 2967 io.Copy(&snapshot, ringBuffer) 2968 err = &smithy.DeserializationError{ 2969 Err: fmt.Errorf("failed to decode response body, %w", err), 2970 Snapshot: snapshot.Bytes(), 2971 } 2972 return out, metadata, err 2973 } 2974 2975 return out, metadata, err 2976} 2977 2978func awsAwsquery_deserializeOpErrorDescribeDBClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2979 var errorBuffer bytes.Buffer 2980 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2981 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2982 } 2983 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2984 2985 errorCode := "UnknownError" 2986 errorMessage := errorCode 2987 2988 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2989 if err != nil { 2990 return err 2991 } 2992 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2993 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2994 } 2995 if len(errorComponents.Code) != 0 { 2996 errorCode = errorComponents.Code 2997 } 2998 if len(errorComponents.Message) != 0 { 2999 errorMessage = errorComponents.Message 3000 } 3001 errorBody.Seek(0, io.SeekStart) 3002 switch { 3003 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 3004 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 3005 3006 default: 3007 genericError := &smithy.GenericAPIError{ 3008 Code: errorCode, 3009 Message: errorMessage, 3010 } 3011 return genericError 3012 3013 } 3014} 3015 3016type awsAwsquery_deserializeOpDescribeDBClusterSnapshotAttributes struct { 3017} 3018 3019func (*awsAwsquery_deserializeOpDescribeDBClusterSnapshotAttributes) ID() string { 3020 return "OperationDeserializer" 3021} 3022 3023func (m *awsAwsquery_deserializeOpDescribeDBClusterSnapshotAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3024 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3025) { 3026 out, metadata, err = next.HandleDeserialize(ctx, in) 3027 if err != nil { 3028 return out, metadata, err 3029 } 3030 3031 response, ok := out.RawResponse.(*smithyhttp.Response) 3032 if !ok { 3033 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3034 } 3035 3036 if response.StatusCode < 200 || response.StatusCode >= 300 { 3037 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshotAttributes(response, &metadata) 3038 } 3039 output := &DescribeDBClusterSnapshotAttributesOutput{} 3040 out.Result = output 3041 3042 var buff [1024]byte 3043 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3044 body := io.TeeReader(response.Body, ringBuffer) 3045 rootDecoder := xml.NewDecoder(body) 3046 t, err := smithyxml.FetchRootElement(rootDecoder) 3047 if err == io.EOF { 3048 return out, metadata, nil 3049 } 3050 if err != nil { 3051 var snapshot bytes.Buffer 3052 io.Copy(&snapshot, ringBuffer) 3053 return out, metadata, &smithy.DeserializationError{ 3054 Err: fmt.Errorf("failed to decode response body, %w", err), 3055 Snapshot: snapshot.Bytes(), 3056 } 3057 } 3058 3059 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3060 t, err = decoder.GetElement("DescribeDBClusterSnapshotAttributesResult") 3061 if err != nil { 3062 var snapshot bytes.Buffer 3063 io.Copy(&snapshot, ringBuffer) 3064 err = &smithy.DeserializationError{ 3065 Err: fmt.Errorf("failed to decode response body, %w", err), 3066 Snapshot: snapshot.Bytes(), 3067 } 3068 return out, metadata, err 3069 } 3070 3071 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3072 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput(&output, decoder) 3073 if err != nil { 3074 var snapshot bytes.Buffer 3075 io.Copy(&snapshot, ringBuffer) 3076 err = &smithy.DeserializationError{ 3077 Err: fmt.Errorf("failed to decode response body, %w", err), 3078 Snapshot: snapshot.Bytes(), 3079 } 3080 return out, metadata, err 3081 } 3082 3083 return out, metadata, err 3084} 3085 3086func awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshotAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3087 var errorBuffer bytes.Buffer 3088 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3089 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3090 } 3091 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3092 3093 errorCode := "UnknownError" 3094 errorMessage := errorCode 3095 3096 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3097 if err != nil { 3098 return err 3099 } 3100 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3101 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3102 } 3103 if len(errorComponents.Code) != 0 { 3104 errorCode = errorComponents.Code 3105 } 3106 if len(errorComponents.Message) != 0 { 3107 errorMessage = errorComponents.Message 3108 } 3109 errorBody.Seek(0, io.SeekStart) 3110 switch { 3111 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 3112 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 3113 3114 default: 3115 genericError := &smithy.GenericAPIError{ 3116 Code: errorCode, 3117 Message: errorMessage, 3118 } 3119 return genericError 3120 3121 } 3122} 3123 3124type awsAwsquery_deserializeOpDescribeDBClusterSnapshots struct { 3125} 3126 3127func (*awsAwsquery_deserializeOpDescribeDBClusterSnapshots) ID() string { 3128 return "OperationDeserializer" 3129} 3130 3131func (m *awsAwsquery_deserializeOpDescribeDBClusterSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3132 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3133) { 3134 out, metadata, err = next.HandleDeserialize(ctx, in) 3135 if err != nil { 3136 return out, metadata, err 3137 } 3138 3139 response, ok := out.RawResponse.(*smithyhttp.Response) 3140 if !ok { 3141 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3142 } 3143 3144 if response.StatusCode < 200 || response.StatusCode >= 300 { 3145 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshots(response, &metadata) 3146 } 3147 output := &DescribeDBClusterSnapshotsOutput{} 3148 out.Result = output 3149 3150 var buff [1024]byte 3151 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3152 body := io.TeeReader(response.Body, ringBuffer) 3153 rootDecoder := xml.NewDecoder(body) 3154 t, err := smithyxml.FetchRootElement(rootDecoder) 3155 if err == io.EOF { 3156 return out, metadata, nil 3157 } 3158 if err != nil { 3159 var snapshot bytes.Buffer 3160 io.Copy(&snapshot, ringBuffer) 3161 return out, metadata, &smithy.DeserializationError{ 3162 Err: fmt.Errorf("failed to decode response body, %w", err), 3163 Snapshot: snapshot.Bytes(), 3164 } 3165 } 3166 3167 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3168 t, err = decoder.GetElement("DescribeDBClusterSnapshotsResult") 3169 if err != nil { 3170 var snapshot bytes.Buffer 3171 io.Copy(&snapshot, ringBuffer) 3172 err = &smithy.DeserializationError{ 3173 Err: fmt.Errorf("failed to decode response body, %w", err), 3174 Snapshot: snapshot.Bytes(), 3175 } 3176 return out, metadata, err 3177 } 3178 3179 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3180 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(&output, decoder) 3181 if err != nil { 3182 var snapshot bytes.Buffer 3183 io.Copy(&snapshot, ringBuffer) 3184 err = &smithy.DeserializationError{ 3185 Err: fmt.Errorf("failed to decode response body, %w", err), 3186 Snapshot: snapshot.Bytes(), 3187 } 3188 return out, metadata, err 3189 } 3190 3191 return out, metadata, err 3192} 3193 3194func awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3195 var errorBuffer bytes.Buffer 3196 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3197 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3198 } 3199 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3200 3201 errorCode := "UnknownError" 3202 errorMessage := errorCode 3203 3204 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3205 if err != nil { 3206 return err 3207 } 3208 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3209 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3210 } 3211 if len(errorComponents.Code) != 0 { 3212 errorCode = errorComponents.Code 3213 } 3214 if len(errorComponents.Message) != 0 { 3215 errorMessage = errorComponents.Message 3216 } 3217 errorBody.Seek(0, io.SeekStart) 3218 switch { 3219 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 3220 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 3221 3222 default: 3223 genericError := &smithy.GenericAPIError{ 3224 Code: errorCode, 3225 Message: errorMessage, 3226 } 3227 return genericError 3228 3229 } 3230} 3231 3232type awsAwsquery_deserializeOpDescribeDBEngineVersions struct { 3233} 3234 3235func (*awsAwsquery_deserializeOpDescribeDBEngineVersions) ID() string { 3236 return "OperationDeserializer" 3237} 3238 3239func (m *awsAwsquery_deserializeOpDescribeDBEngineVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3240 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3241) { 3242 out, metadata, err = next.HandleDeserialize(ctx, in) 3243 if err != nil { 3244 return out, metadata, err 3245 } 3246 3247 response, ok := out.RawResponse.(*smithyhttp.Response) 3248 if !ok { 3249 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3250 } 3251 3252 if response.StatusCode < 200 || response.StatusCode >= 300 { 3253 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBEngineVersions(response, &metadata) 3254 } 3255 output := &DescribeDBEngineVersionsOutput{} 3256 out.Result = output 3257 3258 var buff [1024]byte 3259 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3260 body := io.TeeReader(response.Body, ringBuffer) 3261 rootDecoder := xml.NewDecoder(body) 3262 t, err := smithyxml.FetchRootElement(rootDecoder) 3263 if err == io.EOF { 3264 return out, metadata, nil 3265 } 3266 if err != nil { 3267 var snapshot bytes.Buffer 3268 io.Copy(&snapshot, ringBuffer) 3269 return out, metadata, &smithy.DeserializationError{ 3270 Err: fmt.Errorf("failed to decode response body, %w", err), 3271 Snapshot: snapshot.Bytes(), 3272 } 3273 } 3274 3275 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3276 t, err = decoder.GetElement("DescribeDBEngineVersionsResult") 3277 if err != nil { 3278 var snapshot bytes.Buffer 3279 io.Copy(&snapshot, ringBuffer) 3280 err = &smithy.DeserializationError{ 3281 Err: fmt.Errorf("failed to decode response body, %w", err), 3282 Snapshot: snapshot.Bytes(), 3283 } 3284 return out, metadata, err 3285 } 3286 3287 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3288 err = awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(&output, decoder) 3289 if err != nil { 3290 var snapshot bytes.Buffer 3291 io.Copy(&snapshot, ringBuffer) 3292 err = &smithy.DeserializationError{ 3293 Err: fmt.Errorf("failed to decode response body, %w", err), 3294 Snapshot: snapshot.Bytes(), 3295 } 3296 return out, metadata, err 3297 } 3298 3299 return out, metadata, err 3300} 3301 3302func awsAwsquery_deserializeOpErrorDescribeDBEngineVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3303 var errorBuffer bytes.Buffer 3304 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3305 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3306 } 3307 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3308 3309 errorCode := "UnknownError" 3310 errorMessage := errorCode 3311 3312 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3313 if err != nil { 3314 return err 3315 } 3316 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3317 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3318 } 3319 if len(errorComponents.Code) != 0 { 3320 errorCode = errorComponents.Code 3321 } 3322 if len(errorComponents.Message) != 0 { 3323 errorMessage = errorComponents.Message 3324 } 3325 errorBody.Seek(0, io.SeekStart) 3326 switch { 3327 default: 3328 genericError := &smithy.GenericAPIError{ 3329 Code: errorCode, 3330 Message: errorMessage, 3331 } 3332 return genericError 3333 3334 } 3335} 3336 3337type awsAwsquery_deserializeOpDescribeDBInstances struct { 3338} 3339 3340func (*awsAwsquery_deserializeOpDescribeDBInstances) ID() string { 3341 return "OperationDeserializer" 3342} 3343 3344func (m *awsAwsquery_deserializeOpDescribeDBInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3345 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3346) { 3347 out, metadata, err = next.HandleDeserialize(ctx, in) 3348 if err != nil { 3349 return out, metadata, err 3350 } 3351 3352 response, ok := out.RawResponse.(*smithyhttp.Response) 3353 if !ok { 3354 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3355 } 3356 3357 if response.StatusCode < 200 || response.StatusCode >= 300 { 3358 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBInstances(response, &metadata) 3359 } 3360 output := &DescribeDBInstancesOutput{} 3361 out.Result = output 3362 3363 var buff [1024]byte 3364 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3365 body := io.TeeReader(response.Body, ringBuffer) 3366 rootDecoder := xml.NewDecoder(body) 3367 t, err := smithyxml.FetchRootElement(rootDecoder) 3368 if err == io.EOF { 3369 return out, metadata, nil 3370 } 3371 if err != nil { 3372 var snapshot bytes.Buffer 3373 io.Copy(&snapshot, ringBuffer) 3374 return out, metadata, &smithy.DeserializationError{ 3375 Err: fmt.Errorf("failed to decode response body, %w", err), 3376 Snapshot: snapshot.Bytes(), 3377 } 3378 } 3379 3380 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3381 t, err = decoder.GetElement("DescribeDBInstancesResult") 3382 if err != nil { 3383 var snapshot bytes.Buffer 3384 io.Copy(&snapshot, ringBuffer) 3385 err = &smithy.DeserializationError{ 3386 Err: fmt.Errorf("failed to decode response body, %w", err), 3387 Snapshot: snapshot.Bytes(), 3388 } 3389 return out, metadata, err 3390 } 3391 3392 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3393 err = awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(&output, decoder) 3394 if err != nil { 3395 var snapshot bytes.Buffer 3396 io.Copy(&snapshot, ringBuffer) 3397 err = &smithy.DeserializationError{ 3398 Err: fmt.Errorf("failed to decode response body, %w", err), 3399 Snapshot: snapshot.Bytes(), 3400 } 3401 return out, metadata, err 3402 } 3403 3404 return out, metadata, err 3405} 3406 3407func awsAwsquery_deserializeOpErrorDescribeDBInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3408 var errorBuffer bytes.Buffer 3409 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3410 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3411 } 3412 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3413 3414 errorCode := "UnknownError" 3415 errorMessage := errorCode 3416 3417 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3418 if err != nil { 3419 return err 3420 } 3421 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3422 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3423 } 3424 if len(errorComponents.Code) != 0 { 3425 errorCode = errorComponents.Code 3426 } 3427 if len(errorComponents.Message) != 0 { 3428 errorMessage = errorComponents.Message 3429 } 3430 errorBody.Seek(0, io.SeekStart) 3431 switch { 3432 case strings.EqualFold("DBInstanceNotFound", errorCode): 3433 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 3434 3435 default: 3436 genericError := &smithy.GenericAPIError{ 3437 Code: errorCode, 3438 Message: errorMessage, 3439 } 3440 return genericError 3441 3442 } 3443} 3444 3445type awsAwsquery_deserializeOpDescribeDBParameterGroups struct { 3446} 3447 3448func (*awsAwsquery_deserializeOpDescribeDBParameterGroups) ID() string { 3449 return "OperationDeserializer" 3450} 3451 3452func (m *awsAwsquery_deserializeOpDescribeDBParameterGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3453 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3454) { 3455 out, metadata, err = next.HandleDeserialize(ctx, in) 3456 if err != nil { 3457 return out, metadata, err 3458 } 3459 3460 response, ok := out.RawResponse.(*smithyhttp.Response) 3461 if !ok { 3462 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3463 } 3464 3465 if response.StatusCode < 200 || response.StatusCode >= 300 { 3466 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBParameterGroups(response, &metadata) 3467 } 3468 output := &DescribeDBParameterGroupsOutput{} 3469 out.Result = output 3470 3471 var buff [1024]byte 3472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3473 body := io.TeeReader(response.Body, ringBuffer) 3474 rootDecoder := xml.NewDecoder(body) 3475 t, err := smithyxml.FetchRootElement(rootDecoder) 3476 if err == io.EOF { 3477 return out, metadata, nil 3478 } 3479 if err != nil { 3480 var snapshot bytes.Buffer 3481 io.Copy(&snapshot, ringBuffer) 3482 return out, metadata, &smithy.DeserializationError{ 3483 Err: fmt.Errorf("failed to decode response body, %w", err), 3484 Snapshot: snapshot.Bytes(), 3485 } 3486 } 3487 3488 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3489 t, err = decoder.GetElement("DescribeDBParameterGroupsResult") 3490 if err != nil { 3491 var snapshot bytes.Buffer 3492 io.Copy(&snapshot, ringBuffer) 3493 err = &smithy.DeserializationError{ 3494 Err: fmt.Errorf("failed to decode response body, %w", err), 3495 Snapshot: snapshot.Bytes(), 3496 } 3497 return out, metadata, err 3498 } 3499 3500 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3501 err = awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(&output, decoder) 3502 if err != nil { 3503 var snapshot bytes.Buffer 3504 io.Copy(&snapshot, ringBuffer) 3505 err = &smithy.DeserializationError{ 3506 Err: fmt.Errorf("failed to decode response body, %w", err), 3507 Snapshot: snapshot.Bytes(), 3508 } 3509 return out, metadata, err 3510 } 3511 3512 return out, metadata, err 3513} 3514 3515func awsAwsquery_deserializeOpErrorDescribeDBParameterGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3516 var errorBuffer bytes.Buffer 3517 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3518 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3519 } 3520 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3521 3522 errorCode := "UnknownError" 3523 errorMessage := errorCode 3524 3525 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3526 if err != nil { 3527 return err 3528 } 3529 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3530 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3531 } 3532 if len(errorComponents.Code) != 0 { 3533 errorCode = errorComponents.Code 3534 } 3535 if len(errorComponents.Message) != 0 { 3536 errorMessage = errorComponents.Message 3537 } 3538 errorBody.Seek(0, io.SeekStart) 3539 switch { 3540 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 3541 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 3542 3543 default: 3544 genericError := &smithy.GenericAPIError{ 3545 Code: errorCode, 3546 Message: errorMessage, 3547 } 3548 return genericError 3549 3550 } 3551} 3552 3553type awsAwsquery_deserializeOpDescribeDBParameters struct { 3554} 3555 3556func (*awsAwsquery_deserializeOpDescribeDBParameters) ID() string { 3557 return "OperationDeserializer" 3558} 3559 3560func (m *awsAwsquery_deserializeOpDescribeDBParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3561 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3562) { 3563 out, metadata, err = next.HandleDeserialize(ctx, in) 3564 if err != nil { 3565 return out, metadata, err 3566 } 3567 3568 response, ok := out.RawResponse.(*smithyhttp.Response) 3569 if !ok { 3570 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3571 } 3572 3573 if response.StatusCode < 200 || response.StatusCode >= 300 { 3574 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBParameters(response, &metadata) 3575 } 3576 output := &DescribeDBParametersOutput{} 3577 out.Result = output 3578 3579 var buff [1024]byte 3580 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3581 body := io.TeeReader(response.Body, ringBuffer) 3582 rootDecoder := xml.NewDecoder(body) 3583 t, err := smithyxml.FetchRootElement(rootDecoder) 3584 if err == io.EOF { 3585 return out, metadata, nil 3586 } 3587 if err != nil { 3588 var snapshot bytes.Buffer 3589 io.Copy(&snapshot, ringBuffer) 3590 return out, metadata, &smithy.DeserializationError{ 3591 Err: fmt.Errorf("failed to decode response body, %w", err), 3592 Snapshot: snapshot.Bytes(), 3593 } 3594 } 3595 3596 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3597 t, err = decoder.GetElement("DescribeDBParametersResult") 3598 if err != nil { 3599 var snapshot bytes.Buffer 3600 io.Copy(&snapshot, ringBuffer) 3601 err = &smithy.DeserializationError{ 3602 Err: fmt.Errorf("failed to decode response body, %w", err), 3603 Snapshot: snapshot.Bytes(), 3604 } 3605 return out, metadata, err 3606 } 3607 3608 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3609 err = awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(&output, decoder) 3610 if err != nil { 3611 var snapshot bytes.Buffer 3612 io.Copy(&snapshot, ringBuffer) 3613 err = &smithy.DeserializationError{ 3614 Err: fmt.Errorf("failed to decode response body, %w", err), 3615 Snapshot: snapshot.Bytes(), 3616 } 3617 return out, metadata, err 3618 } 3619 3620 return out, metadata, err 3621} 3622 3623func awsAwsquery_deserializeOpErrorDescribeDBParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3624 var errorBuffer bytes.Buffer 3625 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3626 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3627 } 3628 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3629 3630 errorCode := "UnknownError" 3631 errorMessage := errorCode 3632 3633 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3634 if err != nil { 3635 return err 3636 } 3637 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3638 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3639 } 3640 if len(errorComponents.Code) != 0 { 3641 errorCode = errorComponents.Code 3642 } 3643 if len(errorComponents.Message) != 0 { 3644 errorMessage = errorComponents.Message 3645 } 3646 errorBody.Seek(0, io.SeekStart) 3647 switch { 3648 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 3649 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 3650 3651 default: 3652 genericError := &smithy.GenericAPIError{ 3653 Code: errorCode, 3654 Message: errorMessage, 3655 } 3656 return genericError 3657 3658 } 3659} 3660 3661type awsAwsquery_deserializeOpDescribeDBSubnetGroups struct { 3662} 3663 3664func (*awsAwsquery_deserializeOpDescribeDBSubnetGroups) ID() string { 3665 return "OperationDeserializer" 3666} 3667 3668func (m *awsAwsquery_deserializeOpDescribeDBSubnetGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3669 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3670) { 3671 out, metadata, err = next.HandleDeserialize(ctx, in) 3672 if err != nil { 3673 return out, metadata, err 3674 } 3675 3676 response, ok := out.RawResponse.(*smithyhttp.Response) 3677 if !ok { 3678 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3679 } 3680 3681 if response.StatusCode < 200 || response.StatusCode >= 300 { 3682 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBSubnetGroups(response, &metadata) 3683 } 3684 output := &DescribeDBSubnetGroupsOutput{} 3685 out.Result = output 3686 3687 var buff [1024]byte 3688 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3689 body := io.TeeReader(response.Body, ringBuffer) 3690 rootDecoder := xml.NewDecoder(body) 3691 t, err := smithyxml.FetchRootElement(rootDecoder) 3692 if err == io.EOF { 3693 return out, metadata, nil 3694 } 3695 if err != nil { 3696 var snapshot bytes.Buffer 3697 io.Copy(&snapshot, ringBuffer) 3698 return out, metadata, &smithy.DeserializationError{ 3699 Err: fmt.Errorf("failed to decode response body, %w", err), 3700 Snapshot: snapshot.Bytes(), 3701 } 3702 } 3703 3704 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3705 t, err = decoder.GetElement("DescribeDBSubnetGroupsResult") 3706 if err != nil { 3707 var snapshot bytes.Buffer 3708 io.Copy(&snapshot, ringBuffer) 3709 err = &smithy.DeserializationError{ 3710 Err: fmt.Errorf("failed to decode response body, %w", err), 3711 Snapshot: snapshot.Bytes(), 3712 } 3713 return out, metadata, err 3714 } 3715 3716 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3717 err = awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(&output, decoder) 3718 if err != nil { 3719 var snapshot bytes.Buffer 3720 io.Copy(&snapshot, ringBuffer) 3721 err = &smithy.DeserializationError{ 3722 Err: fmt.Errorf("failed to decode response body, %w", err), 3723 Snapshot: snapshot.Bytes(), 3724 } 3725 return out, metadata, err 3726 } 3727 3728 return out, metadata, err 3729} 3730 3731func awsAwsquery_deserializeOpErrorDescribeDBSubnetGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3732 var errorBuffer bytes.Buffer 3733 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3734 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3735 } 3736 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3737 3738 errorCode := "UnknownError" 3739 errorMessage := errorCode 3740 3741 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3742 if err != nil { 3743 return err 3744 } 3745 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3746 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3747 } 3748 if len(errorComponents.Code) != 0 { 3749 errorCode = errorComponents.Code 3750 } 3751 if len(errorComponents.Message) != 0 { 3752 errorMessage = errorComponents.Message 3753 } 3754 errorBody.Seek(0, io.SeekStart) 3755 switch { 3756 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 3757 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 3758 3759 default: 3760 genericError := &smithy.GenericAPIError{ 3761 Code: errorCode, 3762 Message: errorMessage, 3763 } 3764 return genericError 3765 3766 } 3767} 3768 3769type awsAwsquery_deserializeOpDescribeEngineDefaultClusterParameters struct { 3770} 3771 3772func (*awsAwsquery_deserializeOpDescribeEngineDefaultClusterParameters) ID() string { 3773 return "OperationDeserializer" 3774} 3775 3776func (m *awsAwsquery_deserializeOpDescribeEngineDefaultClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3777 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3778) { 3779 out, metadata, err = next.HandleDeserialize(ctx, in) 3780 if err != nil { 3781 return out, metadata, err 3782 } 3783 3784 response, ok := out.RawResponse.(*smithyhttp.Response) 3785 if !ok { 3786 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3787 } 3788 3789 if response.StatusCode < 200 || response.StatusCode >= 300 { 3790 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEngineDefaultClusterParameters(response, &metadata) 3791 } 3792 output := &DescribeEngineDefaultClusterParametersOutput{} 3793 out.Result = output 3794 3795 var buff [1024]byte 3796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3797 body := io.TeeReader(response.Body, ringBuffer) 3798 rootDecoder := xml.NewDecoder(body) 3799 t, err := smithyxml.FetchRootElement(rootDecoder) 3800 if err == io.EOF { 3801 return out, metadata, nil 3802 } 3803 if err != nil { 3804 var snapshot bytes.Buffer 3805 io.Copy(&snapshot, ringBuffer) 3806 return out, metadata, &smithy.DeserializationError{ 3807 Err: fmt.Errorf("failed to decode response body, %w", err), 3808 Snapshot: snapshot.Bytes(), 3809 } 3810 } 3811 3812 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3813 t, err = decoder.GetElement("DescribeEngineDefaultClusterParametersResult") 3814 if err != nil { 3815 var snapshot bytes.Buffer 3816 io.Copy(&snapshot, ringBuffer) 3817 err = &smithy.DeserializationError{ 3818 Err: fmt.Errorf("failed to decode response body, %w", err), 3819 Snapshot: snapshot.Bytes(), 3820 } 3821 return out, metadata, err 3822 } 3823 3824 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3825 err = awsAwsquery_deserializeOpDocumentDescribeEngineDefaultClusterParametersOutput(&output, decoder) 3826 if err != nil { 3827 var snapshot bytes.Buffer 3828 io.Copy(&snapshot, ringBuffer) 3829 err = &smithy.DeserializationError{ 3830 Err: fmt.Errorf("failed to decode response body, %w", err), 3831 Snapshot: snapshot.Bytes(), 3832 } 3833 return out, metadata, err 3834 } 3835 3836 return out, metadata, err 3837} 3838 3839func awsAwsquery_deserializeOpErrorDescribeEngineDefaultClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3840 var errorBuffer bytes.Buffer 3841 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3842 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3843 } 3844 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3845 3846 errorCode := "UnknownError" 3847 errorMessage := errorCode 3848 3849 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3850 if err != nil { 3851 return err 3852 } 3853 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3854 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3855 } 3856 if len(errorComponents.Code) != 0 { 3857 errorCode = errorComponents.Code 3858 } 3859 if len(errorComponents.Message) != 0 { 3860 errorMessage = errorComponents.Message 3861 } 3862 errorBody.Seek(0, io.SeekStart) 3863 switch { 3864 default: 3865 genericError := &smithy.GenericAPIError{ 3866 Code: errorCode, 3867 Message: errorMessage, 3868 } 3869 return genericError 3870 3871 } 3872} 3873 3874type awsAwsquery_deserializeOpDescribeEngineDefaultParameters struct { 3875} 3876 3877func (*awsAwsquery_deserializeOpDescribeEngineDefaultParameters) ID() string { 3878 return "OperationDeserializer" 3879} 3880 3881func (m *awsAwsquery_deserializeOpDescribeEngineDefaultParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3882 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3883) { 3884 out, metadata, err = next.HandleDeserialize(ctx, in) 3885 if err != nil { 3886 return out, metadata, err 3887 } 3888 3889 response, ok := out.RawResponse.(*smithyhttp.Response) 3890 if !ok { 3891 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3892 } 3893 3894 if response.StatusCode < 200 || response.StatusCode >= 300 { 3895 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEngineDefaultParameters(response, &metadata) 3896 } 3897 output := &DescribeEngineDefaultParametersOutput{} 3898 out.Result = output 3899 3900 var buff [1024]byte 3901 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3902 body := io.TeeReader(response.Body, ringBuffer) 3903 rootDecoder := xml.NewDecoder(body) 3904 t, err := smithyxml.FetchRootElement(rootDecoder) 3905 if err == io.EOF { 3906 return out, metadata, nil 3907 } 3908 if err != nil { 3909 var snapshot bytes.Buffer 3910 io.Copy(&snapshot, ringBuffer) 3911 return out, metadata, &smithy.DeserializationError{ 3912 Err: fmt.Errorf("failed to decode response body, %w", err), 3913 Snapshot: snapshot.Bytes(), 3914 } 3915 } 3916 3917 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3918 t, err = decoder.GetElement("DescribeEngineDefaultParametersResult") 3919 if err != nil { 3920 var snapshot bytes.Buffer 3921 io.Copy(&snapshot, ringBuffer) 3922 err = &smithy.DeserializationError{ 3923 Err: fmt.Errorf("failed to decode response body, %w", err), 3924 Snapshot: snapshot.Bytes(), 3925 } 3926 return out, metadata, err 3927 } 3928 3929 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3930 err = awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(&output, decoder) 3931 if err != nil { 3932 var snapshot bytes.Buffer 3933 io.Copy(&snapshot, ringBuffer) 3934 err = &smithy.DeserializationError{ 3935 Err: fmt.Errorf("failed to decode response body, %w", err), 3936 Snapshot: snapshot.Bytes(), 3937 } 3938 return out, metadata, err 3939 } 3940 3941 return out, metadata, err 3942} 3943 3944func awsAwsquery_deserializeOpErrorDescribeEngineDefaultParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3945 var errorBuffer bytes.Buffer 3946 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3947 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3948 } 3949 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3950 3951 errorCode := "UnknownError" 3952 errorMessage := errorCode 3953 3954 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3955 if err != nil { 3956 return err 3957 } 3958 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3959 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3960 } 3961 if len(errorComponents.Code) != 0 { 3962 errorCode = errorComponents.Code 3963 } 3964 if len(errorComponents.Message) != 0 { 3965 errorMessage = errorComponents.Message 3966 } 3967 errorBody.Seek(0, io.SeekStart) 3968 switch { 3969 default: 3970 genericError := &smithy.GenericAPIError{ 3971 Code: errorCode, 3972 Message: errorMessage, 3973 } 3974 return genericError 3975 3976 } 3977} 3978 3979type awsAwsquery_deserializeOpDescribeEventCategories struct { 3980} 3981 3982func (*awsAwsquery_deserializeOpDescribeEventCategories) ID() string { 3983 return "OperationDeserializer" 3984} 3985 3986func (m *awsAwsquery_deserializeOpDescribeEventCategories) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3987 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3988) { 3989 out, metadata, err = next.HandleDeserialize(ctx, in) 3990 if err != nil { 3991 return out, metadata, err 3992 } 3993 3994 response, ok := out.RawResponse.(*smithyhttp.Response) 3995 if !ok { 3996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3997 } 3998 3999 if response.StatusCode < 200 || response.StatusCode >= 300 { 4000 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEventCategories(response, &metadata) 4001 } 4002 output := &DescribeEventCategoriesOutput{} 4003 out.Result = output 4004 4005 var buff [1024]byte 4006 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4007 body := io.TeeReader(response.Body, ringBuffer) 4008 rootDecoder := xml.NewDecoder(body) 4009 t, err := smithyxml.FetchRootElement(rootDecoder) 4010 if err == io.EOF { 4011 return out, metadata, nil 4012 } 4013 if err != nil { 4014 var snapshot bytes.Buffer 4015 io.Copy(&snapshot, ringBuffer) 4016 return out, metadata, &smithy.DeserializationError{ 4017 Err: fmt.Errorf("failed to decode response body, %w", err), 4018 Snapshot: snapshot.Bytes(), 4019 } 4020 } 4021 4022 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4023 t, err = decoder.GetElement("DescribeEventCategoriesResult") 4024 if err != nil { 4025 var snapshot bytes.Buffer 4026 io.Copy(&snapshot, ringBuffer) 4027 err = &smithy.DeserializationError{ 4028 Err: fmt.Errorf("failed to decode response body, %w", err), 4029 Snapshot: snapshot.Bytes(), 4030 } 4031 return out, metadata, err 4032 } 4033 4034 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4035 err = awsAwsquery_deserializeOpDocumentDescribeEventCategoriesOutput(&output, decoder) 4036 if err != nil { 4037 var snapshot bytes.Buffer 4038 io.Copy(&snapshot, ringBuffer) 4039 err = &smithy.DeserializationError{ 4040 Err: fmt.Errorf("failed to decode response body, %w", err), 4041 Snapshot: snapshot.Bytes(), 4042 } 4043 return out, metadata, err 4044 } 4045 4046 return out, metadata, err 4047} 4048 4049func awsAwsquery_deserializeOpErrorDescribeEventCategories(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4050 var errorBuffer bytes.Buffer 4051 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4052 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4053 } 4054 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4055 4056 errorCode := "UnknownError" 4057 errorMessage := errorCode 4058 4059 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4060 if err != nil { 4061 return err 4062 } 4063 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4064 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4065 } 4066 if len(errorComponents.Code) != 0 { 4067 errorCode = errorComponents.Code 4068 } 4069 if len(errorComponents.Message) != 0 { 4070 errorMessage = errorComponents.Message 4071 } 4072 errorBody.Seek(0, io.SeekStart) 4073 switch { 4074 default: 4075 genericError := &smithy.GenericAPIError{ 4076 Code: errorCode, 4077 Message: errorMessage, 4078 } 4079 return genericError 4080 4081 } 4082} 4083 4084type awsAwsquery_deserializeOpDescribeEvents struct { 4085} 4086 4087func (*awsAwsquery_deserializeOpDescribeEvents) ID() string { 4088 return "OperationDeserializer" 4089} 4090 4091func (m *awsAwsquery_deserializeOpDescribeEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4092 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4093) { 4094 out, metadata, err = next.HandleDeserialize(ctx, in) 4095 if err != nil { 4096 return out, metadata, err 4097 } 4098 4099 response, ok := out.RawResponse.(*smithyhttp.Response) 4100 if !ok { 4101 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4102 } 4103 4104 if response.StatusCode < 200 || response.StatusCode >= 300 { 4105 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEvents(response, &metadata) 4106 } 4107 output := &DescribeEventsOutput{} 4108 out.Result = output 4109 4110 var buff [1024]byte 4111 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4112 body := io.TeeReader(response.Body, ringBuffer) 4113 rootDecoder := xml.NewDecoder(body) 4114 t, err := smithyxml.FetchRootElement(rootDecoder) 4115 if err == io.EOF { 4116 return out, metadata, nil 4117 } 4118 if err != nil { 4119 var snapshot bytes.Buffer 4120 io.Copy(&snapshot, ringBuffer) 4121 return out, metadata, &smithy.DeserializationError{ 4122 Err: fmt.Errorf("failed to decode response body, %w", err), 4123 Snapshot: snapshot.Bytes(), 4124 } 4125 } 4126 4127 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4128 t, err = decoder.GetElement("DescribeEventsResult") 4129 if err != nil { 4130 var snapshot bytes.Buffer 4131 io.Copy(&snapshot, ringBuffer) 4132 err = &smithy.DeserializationError{ 4133 Err: fmt.Errorf("failed to decode response body, %w", err), 4134 Snapshot: snapshot.Bytes(), 4135 } 4136 return out, metadata, err 4137 } 4138 4139 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4140 err = awsAwsquery_deserializeOpDocumentDescribeEventsOutput(&output, decoder) 4141 if err != nil { 4142 var snapshot bytes.Buffer 4143 io.Copy(&snapshot, ringBuffer) 4144 err = &smithy.DeserializationError{ 4145 Err: fmt.Errorf("failed to decode response body, %w", err), 4146 Snapshot: snapshot.Bytes(), 4147 } 4148 return out, metadata, err 4149 } 4150 4151 return out, metadata, err 4152} 4153 4154func awsAwsquery_deserializeOpErrorDescribeEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4155 var errorBuffer bytes.Buffer 4156 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4157 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4158 } 4159 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4160 4161 errorCode := "UnknownError" 4162 errorMessage := errorCode 4163 4164 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4165 if err != nil { 4166 return err 4167 } 4168 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4169 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4170 } 4171 if len(errorComponents.Code) != 0 { 4172 errorCode = errorComponents.Code 4173 } 4174 if len(errorComponents.Message) != 0 { 4175 errorMessage = errorComponents.Message 4176 } 4177 errorBody.Seek(0, io.SeekStart) 4178 switch { 4179 default: 4180 genericError := &smithy.GenericAPIError{ 4181 Code: errorCode, 4182 Message: errorMessage, 4183 } 4184 return genericError 4185 4186 } 4187} 4188 4189type awsAwsquery_deserializeOpDescribeEventSubscriptions struct { 4190} 4191 4192func (*awsAwsquery_deserializeOpDescribeEventSubscriptions) ID() string { 4193 return "OperationDeserializer" 4194} 4195 4196func (m *awsAwsquery_deserializeOpDescribeEventSubscriptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4197 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4198) { 4199 out, metadata, err = next.HandleDeserialize(ctx, in) 4200 if err != nil { 4201 return out, metadata, err 4202 } 4203 4204 response, ok := out.RawResponse.(*smithyhttp.Response) 4205 if !ok { 4206 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4207 } 4208 4209 if response.StatusCode < 200 || response.StatusCode >= 300 { 4210 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEventSubscriptions(response, &metadata) 4211 } 4212 output := &DescribeEventSubscriptionsOutput{} 4213 out.Result = output 4214 4215 var buff [1024]byte 4216 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4217 body := io.TeeReader(response.Body, ringBuffer) 4218 rootDecoder := xml.NewDecoder(body) 4219 t, err := smithyxml.FetchRootElement(rootDecoder) 4220 if err == io.EOF { 4221 return out, metadata, nil 4222 } 4223 if err != nil { 4224 var snapshot bytes.Buffer 4225 io.Copy(&snapshot, ringBuffer) 4226 return out, metadata, &smithy.DeserializationError{ 4227 Err: fmt.Errorf("failed to decode response body, %w", err), 4228 Snapshot: snapshot.Bytes(), 4229 } 4230 } 4231 4232 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4233 t, err = decoder.GetElement("DescribeEventSubscriptionsResult") 4234 if err != nil { 4235 var snapshot bytes.Buffer 4236 io.Copy(&snapshot, ringBuffer) 4237 err = &smithy.DeserializationError{ 4238 Err: fmt.Errorf("failed to decode response body, %w", err), 4239 Snapshot: snapshot.Bytes(), 4240 } 4241 return out, metadata, err 4242 } 4243 4244 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4245 err = awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(&output, decoder) 4246 if err != nil { 4247 var snapshot bytes.Buffer 4248 io.Copy(&snapshot, ringBuffer) 4249 err = &smithy.DeserializationError{ 4250 Err: fmt.Errorf("failed to decode response body, %w", err), 4251 Snapshot: snapshot.Bytes(), 4252 } 4253 return out, metadata, err 4254 } 4255 4256 return out, metadata, err 4257} 4258 4259func awsAwsquery_deserializeOpErrorDescribeEventSubscriptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4260 var errorBuffer bytes.Buffer 4261 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4262 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4263 } 4264 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4265 4266 errorCode := "UnknownError" 4267 errorMessage := errorCode 4268 4269 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4270 if err != nil { 4271 return err 4272 } 4273 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4274 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4275 } 4276 if len(errorComponents.Code) != 0 { 4277 errorCode = errorComponents.Code 4278 } 4279 if len(errorComponents.Message) != 0 { 4280 errorMessage = errorComponents.Message 4281 } 4282 errorBody.Seek(0, io.SeekStart) 4283 switch { 4284 case strings.EqualFold("SubscriptionNotFound", errorCode): 4285 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 4286 4287 default: 4288 genericError := &smithy.GenericAPIError{ 4289 Code: errorCode, 4290 Message: errorMessage, 4291 } 4292 return genericError 4293 4294 } 4295} 4296 4297type awsAwsquery_deserializeOpDescribeOrderableDBInstanceOptions struct { 4298} 4299 4300func (*awsAwsquery_deserializeOpDescribeOrderableDBInstanceOptions) ID() string { 4301 return "OperationDeserializer" 4302} 4303 4304func (m *awsAwsquery_deserializeOpDescribeOrderableDBInstanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4305 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4306) { 4307 out, metadata, err = next.HandleDeserialize(ctx, in) 4308 if err != nil { 4309 return out, metadata, err 4310 } 4311 4312 response, ok := out.RawResponse.(*smithyhttp.Response) 4313 if !ok { 4314 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4315 } 4316 4317 if response.StatusCode < 200 || response.StatusCode >= 300 { 4318 return out, metadata, awsAwsquery_deserializeOpErrorDescribeOrderableDBInstanceOptions(response, &metadata) 4319 } 4320 output := &DescribeOrderableDBInstanceOptionsOutput{} 4321 out.Result = output 4322 4323 var buff [1024]byte 4324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4325 body := io.TeeReader(response.Body, ringBuffer) 4326 rootDecoder := xml.NewDecoder(body) 4327 t, err := smithyxml.FetchRootElement(rootDecoder) 4328 if err == io.EOF { 4329 return out, metadata, nil 4330 } 4331 if err != nil { 4332 var snapshot bytes.Buffer 4333 io.Copy(&snapshot, ringBuffer) 4334 return out, metadata, &smithy.DeserializationError{ 4335 Err: fmt.Errorf("failed to decode response body, %w", err), 4336 Snapshot: snapshot.Bytes(), 4337 } 4338 } 4339 4340 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4341 t, err = decoder.GetElement("DescribeOrderableDBInstanceOptionsResult") 4342 if err != nil { 4343 var snapshot bytes.Buffer 4344 io.Copy(&snapshot, ringBuffer) 4345 err = &smithy.DeserializationError{ 4346 Err: fmt.Errorf("failed to decode response body, %w", err), 4347 Snapshot: snapshot.Bytes(), 4348 } 4349 return out, metadata, err 4350 } 4351 4352 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4353 err = awsAwsquery_deserializeOpDocumentDescribeOrderableDBInstanceOptionsOutput(&output, decoder) 4354 if err != nil { 4355 var snapshot bytes.Buffer 4356 io.Copy(&snapshot, ringBuffer) 4357 err = &smithy.DeserializationError{ 4358 Err: fmt.Errorf("failed to decode response body, %w", err), 4359 Snapshot: snapshot.Bytes(), 4360 } 4361 return out, metadata, err 4362 } 4363 4364 return out, metadata, err 4365} 4366 4367func awsAwsquery_deserializeOpErrorDescribeOrderableDBInstanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4368 var errorBuffer bytes.Buffer 4369 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4370 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4371 } 4372 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4373 4374 errorCode := "UnknownError" 4375 errorMessage := errorCode 4376 4377 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4378 if err != nil { 4379 return err 4380 } 4381 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4382 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4383 } 4384 if len(errorComponents.Code) != 0 { 4385 errorCode = errorComponents.Code 4386 } 4387 if len(errorComponents.Message) != 0 { 4388 errorMessage = errorComponents.Message 4389 } 4390 errorBody.Seek(0, io.SeekStart) 4391 switch { 4392 default: 4393 genericError := &smithy.GenericAPIError{ 4394 Code: errorCode, 4395 Message: errorMessage, 4396 } 4397 return genericError 4398 4399 } 4400} 4401 4402type awsAwsquery_deserializeOpDescribePendingMaintenanceActions struct { 4403} 4404 4405func (*awsAwsquery_deserializeOpDescribePendingMaintenanceActions) ID() string { 4406 return "OperationDeserializer" 4407} 4408 4409func (m *awsAwsquery_deserializeOpDescribePendingMaintenanceActions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4410 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4411) { 4412 out, metadata, err = next.HandleDeserialize(ctx, in) 4413 if err != nil { 4414 return out, metadata, err 4415 } 4416 4417 response, ok := out.RawResponse.(*smithyhttp.Response) 4418 if !ok { 4419 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4420 } 4421 4422 if response.StatusCode < 200 || response.StatusCode >= 300 { 4423 return out, metadata, awsAwsquery_deserializeOpErrorDescribePendingMaintenanceActions(response, &metadata) 4424 } 4425 output := &DescribePendingMaintenanceActionsOutput{} 4426 out.Result = output 4427 4428 var buff [1024]byte 4429 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4430 body := io.TeeReader(response.Body, ringBuffer) 4431 rootDecoder := xml.NewDecoder(body) 4432 t, err := smithyxml.FetchRootElement(rootDecoder) 4433 if err == io.EOF { 4434 return out, metadata, nil 4435 } 4436 if err != nil { 4437 var snapshot bytes.Buffer 4438 io.Copy(&snapshot, ringBuffer) 4439 return out, metadata, &smithy.DeserializationError{ 4440 Err: fmt.Errorf("failed to decode response body, %w", err), 4441 Snapshot: snapshot.Bytes(), 4442 } 4443 } 4444 4445 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4446 t, err = decoder.GetElement("DescribePendingMaintenanceActionsResult") 4447 if err != nil { 4448 var snapshot bytes.Buffer 4449 io.Copy(&snapshot, ringBuffer) 4450 err = &smithy.DeserializationError{ 4451 Err: fmt.Errorf("failed to decode response body, %w", err), 4452 Snapshot: snapshot.Bytes(), 4453 } 4454 return out, metadata, err 4455 } 4456 4457 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4458 err = awsAwsquery_deserializeOpDocumentDescribePendingMaintenanceActionsOutput(&output, decoder) 4459 if err != nil { 4460 var snapshot bytes.Buffer 4461 io.Copy(&snapshot, ringBuffer) 4462 err = &smithy.DeserializationError{ 4463 Err: fmt.Errorf("failed to decode response body, %w", err), 4464 Snapshot: snapshot.Bytes(), 4465 } 4466 return out, metadata, err 4467 } 4468 4469 return out, metadata, err 4470} 4471 4472func awsAwsquery_deserializeOpErrorDescribePendingMaintenanceActions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4473 var errorBuffer bytes.Buffer 4474 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4475 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4476 } 4477 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4478 4479 errorCode := "UnknownError" 4480 errorMessage := errorCode 4481 4482 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4483 if err != nil { 4484 return err 4485 } 4486 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4487 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4488 } 4489 if len(errorComponents.Code) != 0 { 4490 errorCode = errorComponents.Code 4491 } 4492 if len(errorComponents.Message) != 0 { 4493 errorMessage = errorComponents.Message 4494 } 4495 errorBody.Seek(0, io.SeekStart) 4496 switch { 4497 case strings.EqualFold("ResourceNotFoundFault", errorCode): 4498 return awsAwsquery_deserializeErrorResourceNotFoundFault(response, errorBody) 4499 4500 default: 4501 genericError := &smithy.GenericAPIError{ 4502 Code: errorCode, 4503 Message: errorMessage, 4504 } 4505 return genericError 4506 4507 } 4508} 4509 4510type awsAwsquery_deserializeOpDescribeValidDBInstanceModifications struct { 4511} 4512 4513func (*awsAwsquery_deserializeOpDescribeValidDBInstanceModifications) ID() string { 4514 return "OperationDeserializer" 4515} 4516 4517func (m *awsAwsquery_deserializeOpDescribeValidDBInstanceModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4518 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4519) { 4520 out, metadata, err = next.HandleDeserialize(ctx, in) 4521 if err != nil { 4522 return out, metadata, err 4523 } 4524 4525 response, ok := out.RawResponse.(*smithyhttp.Response) 4526 if !ok { 4527 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4528 } 4529 4530 if response.StatusCode < 200 || response.StatusCode >= 300 { 4531 return out, metadata, awsAwsquery_deserializeOpErrorDescribeValidDBInstanceModifications(response, &metadata) 4532 } 4533 output := &DescribeValidDBInstanceModificationsOutput{} 4534 out.Result = output 4535 4536 var buff [1024]byte 4537 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4538 body := io.TeeReader(response.Body, ringBuffer) 4539 rootDecoder := xml.NewDecoder(body) 4540 t, err := smithyxml.FetchRootElement(rootDecoder) 4541 if err == io.EOF { 4542 return out, metadata, nil 4543 } 4544 if err != nil { 4545 var snapshot bytes.Buffer 4546 io.Copy(&snapshot, ringBuffer) 4547 return out, metadata, &smithy.DeserializationError{ 4548 Err: fmt.Errorf("failed to decode response body, %w", err), 4549 Snapshot: snapshot.Bytes(), 4550 } 4551 } 4552 4553 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4554 t, err = decoder.GetElement("DescribeValidDBInstanceModificationsResult") 4555 if err != nil { 4556 var snapshot bytes.Buffer 4557 io.Copy(&snapshot, ringBuffer) 4558 err = &smithy.DeserializationError{ 4559 Err: fmt.Errorf("failed to decode response body, %w", err), 4560 Snapshot: snapshot.Bytes(), 4561 } 4562 return out, metadata, err 4563 } 4564 4565 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4566 err = awsAwsquery_deserializeOpDocumentDescribeValidDBInstanceModificationsOutput(&output, decoder) 4567 if err != nil { 4568 var snapshot bytes.Buffer 4569 io.Copy(&snapshot, ringBuffer) 4570 err = &smithy.DeserializationError{ 4571 Err: fmt.Errorf("failed to decode response body, %w", err), 4572 Snapshot: snapshot.Bytes(), 4573 } 4574 return out, metadata, err 4575 } 4576 4577 return out, metadata, err 4578} 4579 4580func awsAwsquery_deserializeOpErrorDescribeValidDBInstanceModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4581 var errorBuffer bytes.Buffer 4582 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4583 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4584 } 4585 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4586 4587 errorCode := "UnknownError" 4588 errorMessage := errorCode 4589 4590 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4591 if err != nil { 4592 return err 4593 } 4594 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4595 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4596 } 4597 if len(errorComponents.Code) != 0 { 4598 errorCode = errorComponents.Code 4599 } 4600 if len(errorComponents.Message) != 0 { 4601 errorMessage = errorComponents.Message 4602 } 4603 errorBody.Seek(0, io.SeekStart) 4604 switch { 4605 case strings.EqualFold("DBInstanceNotFound", errorCode): 4606 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 4607 4608 case strings.EqualFold("InvalidDBInstanceState", errorCode): 4609 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 4610 4611 default: 4612 genericError := &smithy.GenericAPIError{ 4613 Code: errorCode, 4614 Message: errorMessage, 4615 } 4616 return genericError 4617 4618 } 4619} 4620 4621type awsAwsquery_deserializeOpFailoverDBCluster struct { 4622} 4623 4624func (*awsAwsquery_deserializeOpFailoverDBCluster) ID() string { 4625 return "OperationDeserializer" 4626} 4627 4628func (m *awsAwsquery_deserializeOpFailoverDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4629 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4630) { 4631 out, metadata, err = next.HandleDeserialize(ctx, in) 4632 if err != nil { 4633 return out, metadata, err 4634 } 4635 4636 response, ok := out.RawResponse.(*smithyhttp.Response) 4637 if !ok { 4638 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4639 } 4640 4641 if response.StatusCode < 200 || response.StatusCode >= 300 { 4642 return out, metadata, awsAwsquery_deserializeOpErrorFailoverDBCluster(response, &metadata) 4643 } 4644 output := &FailoverDBClusterOutput{} 4645 out.Result = output 4646 4647 var buff [1024]byte 4648 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4649 body := io.TeeReader(response.Body, ringBuffer) 4650 rootDecoder := xml.NewDecoder(body) 4651 t, err := smithyxml.FetchRootElement(rootDecoder) 4652 if err == io.EOF { 4653 return out, metadata, nil 4654 } 4655 if err != nil { 4656 var snapshot bytes.Buffer 4657 io.Copy(&snapshot, ringBuffer) 4658 return out, metadata, &smithy.DeserializationError{ 4659 Err: fmt.Errorf("failed to decode response body, %w", err), 4660 Snapshot: snapshot.Bytes(), 4661 } 4662 } 4663 4664 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4665 t, err = decoder.GetElement("FailoverDBClusterResult") 4666 if err != nil { 4667 var snapshot bytes.Buffer 4668 io.Copy(&snapshot, ringBuffer) 4669 err = &smithy.DeserializationError{ 4670 Err: fmt.Errorf("failed to decode response body, %w", err), 4671 Snapshot: snapshot.Bytes(), 4672 } 4673 return out, metadata, err 4674 } 4675 4676 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4677 err = awsAwsquery_deserializeOpDocumentFailoverDBClusterOutput(&output, decoder) 4678 if err != nil { 4679 var snapshot bytes.Buffer 4680 io.Copy(&snapshot, ringBuffer) 4681 err = &smithy.DeserializationError{ 4682 Err: fmt.Errorf("failed to decode response body, %w", err), 4683 Snapshot: snapshot.Bytes(), 4684 } 4685 return out, metadata, err 4686 } 4687 4688 return out, metadata, err 4689} 4690 4691func awsAwsquery_deserializeOpErrorFailoverDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4692 var errorBuffer bytes.Buffer 4693 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4694 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4695 } 4696 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4697 4698 errorCode := "UnknownError" 4699 errorMessage := errorCode 4700 4701 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4702 if err != nil { 4703 return err 4704 } 4705 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4706 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4707 } 4708 if len(errorComponents.Code) != 0 { 4709 errorCode = errorComponents.Code 4710 } 4711 if len(errorComponents.Message) != 0 { 4712 errorMessage = errorComponents.Message 4713 } 4714 errorBody.Seek(0, io.SeekStart) 4715 switch { 4716 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 4717 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 4718 4719 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 4720 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 4721 4722 case strings.EqualFold("InvalidDBInstanceState", errorCode): 4723 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 4724 4725 default: 4726 genericError := &smithy.GenericAPIError{ 4727 Code: errorCode, 4728 Message: errorMessage, 4729 } 4730 return genericError 4731 4732 } 4733} 4734 4735type awsAwsquery_deserializeOpListTagsForResource struct { 4736} 4737 4738func (*awsAwsquery_deserializeOpListTagsForResource) ID() string { 4739 return "OperationDeserializer" 4740} 4741 4742func (m *awsAwsquery_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4743 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4744) { 4745 out, metadata, err = next.HandleDeserialize(ctx, in) 4746 if err != nil { 4747 return out, metadata, err 4748 } 4749 4750 response, ok := out.RawResponse.(*smithyhttp.Response) 4751 if !ok { 4752 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4753 } 4754 4755 if response.StatusCode < 200 || response.StatusCode >= 300 { 4756 return out, metadata, awsAwsquery_deserializeOpErrorListTagsForResource(response, &metadata) 4757 } 4758 output := &ListTagsForResourceOutput{} 4759 out.Result = output 4760 4761 var buff [1024]byte 4762 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4763 body := io.TeeReader(response.Body, ringBuffer) 4764 rootDecoder := xml.NewDecoder(body) 4765 t, err := smithyxml.FetchRootElement(rootDecoder) 4766 if err == io.EOF { 4767 return out, metadata, nil 4768 } 4769 if err != nil { 4770 var snapshot bytes.Buffer 4771 io.Copy(&snapshot, ringBuffer) 4772 return out, metadata, &smithy.DeserializationError{ 4773 Err: fmt.Errorf("failed to decode response body, %w", err), 4774 Snapshot: snapshot.Bytes(), 4775 } 4776 } 4777 4778 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4779 t, err = decoder.GetElement("ListTagsForResourceResult") 4780 if err != nil { 4781 var snapshot bytes.Buffer 4782 io.Copy(&snapshot, ringBuffer) 4783 err = &smithy.DeserializationError{ 4784 Err: fmt.Errorf("failed to decode response body, %w", err), 4785 Snapshot: snapshot.Bytes(), 4786 } 4787 return out, metadata, err 4788 } 4789 4790 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4791 err = awsAwsquery_deserializeOpDocumentListTagsForResourceOutput(&output, decoder) 4792 if err != nil { 4793 var snapshot bytes.Buffer 4794 io.Copy(&snapshot, ringBuffer) 4795 err = &smithy.DeserializationError{ 4796 Err: fmt.Errorf("failed to decode response body, %w", err), 4797 Snapshot: snapshot.Bytes(), 4798 } 4799 return out, metadata, err 4800 } 4801 4802 return out, metadata, err 4803} 4804 4805func awsAwsquery_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4806 var errorBuffer bytes.Buffer 4807 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4808 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4809 } 4810 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4811 4812 errorCode := "UnknownError" 4813 errorMessage := errorCode 4814 4815 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4816 if err != nil { 4817 return err 4818 } 4819 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4820 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4821 } 4822 if len(errorComponents.Code) != 0 { 4823 errorCode = errorComponents.Code 4824 } 4825 if len(errorComponents.Message) != 0 { 4826 errorMessage = errorComponents.Message 4827 } 4828 errorBody.Seek(0, io.SeekStart) 4829 switch { 4830 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 4831 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 4832 4833 case strings.EqualFold("DBInstanceNotFound", errorCode): 4834 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 4835 4836 case strings.EqualFold("DBSnapshotNotFound", errorCode): 4837 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 4838 4839 default: 4840 genericError := &smithy.GenericAPIError{ 4841 Code: errorCode, 4842 Message: errorMessage, 4843 } 4844 return genericError 4845 4846 } 4847} 4848 4849type awsAwsquery_deserializeOpModifyDBCluster struct { 4850} 4851 4852func (*awsAwsquery_deserializeOpModifyDBCluster) ID() string { 4853 return "OperationDeserializer" 4854} 4855 4856func (m *awsAwsquery_deserializeOpModifyDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4857 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4858) { 4859 out, metadata, err = next.HandleDeserialize(ctx, in) 4860 if err != nil { 4861 return out, metadata, err 4862 } 4863 4864 response, ok := out.RawResponse.(*smithyhttp.Response) 4865 if !ok { 4866 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4867 } 4868 4869 if response.StatusCode < 200 || response.StatusCode >= 300 { 4870 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBCluster(response, &metadata) 4871 } 4872 output := &ModifyDBClusterOutput{} 4873 out.Result = output 4874 4875 var buff [1024]byte 4876 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4877 body := io.TeeReader(response.Body, ringBuffer) 4878 rootDecoder := xml.NewDecoder(body) 4879 t, err := smithyxml.FetchRootElement(rootDecoder) 4880 if err == io.EOF { 4881 return out, metadata, nil 4882 } 4883 if err != nil { 4884 var snapshot bytes.Buffer 4885 io.Copy(&snapshot, ringBuffer) 4886 return out, metadata, &smithy.DeserializationError{ 4887 Err: fmt.Errorf("failed to decode response body, %w", err), 4888 Snapshot: snapshot.Bytes(), 4889 } 4890 } 4891 4892 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4893 t, err = decoder.GetElement("ModifyDBClusterResult") 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 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4905 err = awsAwsquery_deserializeOpDocumentModifyDBClusterOutput(&output, decoder) 4906 if err != nil { 4907 var snapshot bytes.Buffer 4908 io.Copy(&snapshot, ringBuffer) 4909 err = &smithy.DeserializationError{ 4910 Err: fmt.Errorf("failed to decode response body, %w", err), 4911 Snapshot: snapshot.Bytes(), 4912 } 4913 return out, metadata, err 4914 } 4915 4916 return out, metadata, err 4917} 4918 4919func awsAwsquery_deserializeOpErrorModifyDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4920 var errorBuffer bytes.Buffer 4921 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4922 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4923 } 4924 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4925 4926 errorCode := "UnknownError" 4927 errorMessage := errorCode 4928 4929 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4930 if err != nil { 4931 return err 4932 } 4933 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4934 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4935 } 4936 if len(errorComponents.Code) != 0 { 4937 errorCode = errorComponents.Code 4938 } 4939 if len(errorComponents.Message) != 0 { 4940 errorMessage = errorComponents.Message 4941 } 4942 errorBody.Seek(0, io.SeekStart) 4943 switch { 4944 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 4945 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 4946 4947 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 4948 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 4949 4950 case strings.EqualFold("DBClusterParameterGroupNotFound", errorCode): 4951 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 4952 4953 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 4954 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 4955 4956 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 4957 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 4958 4959 case strings.EqualFold("InvalidDBInstanceState", errorCode): 4960 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 4961 4962 case strings.EqualFold("InvalidDBSecurityGroupState", errorCode): 4963 return awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response, errorBody) 4964 4965 case strings.EqualFold("InvalidDBSubnetGroupStateFault", errorCode): 4966 return awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response, errorBody) 4967 4968 case strings.EqualFold("InvalidSubnet", errorCode): 4969 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 4970 4971 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 4972 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 4973 4974 case strings.EqualFold("StorageQuotaExceeded", errorCode): 4975 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 4976 4977 default: 4978 genericError := &smithy.GenericAPIError{ 4979 Code: errorCode, 4980 Message: errorMessage, 4981 } 4982 return genericError 4983 4984 } 4985} 4986 4987type awsAwsquery_deserializeOpModifyDBClusterEndpoint struct { 4988} 4989 4990func (*awsAwsquery_deserializeOpModifyDBClusterEndpoint) ID() string { 4991 return "OperationDeserializer" 4992} 4993 4994func (m *awsAwsquery_deserializeOpModifyDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4995 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4996) { 4997 out, metadata, err = next.HandleDeserialize(ctx, in) 4998 if err != nil { 4999 return out, metadata, err 5000 } 5001 5002 response, ok := out.RawResponse.(*smithyhttp.Response) 5003 if !ok { 5004 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5005 } 5006 5007 if response.StatusCode < 200 || response.StatusCode >= 300 { 5008 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBClusterEndpoint(response, &metadata) 5009 } 5010 output := &ModifyDBClusterEndpointOutput{} 5011 out.Result = output 5012 5013 var buff [1024]byte 5014 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5015 body := io.TeeReader(response.Body, ringBuffer) 5016 rootDecoder := xml.NewDecoder(body) 5017 t, err := smithyxml.FetchRootElement(rootDecoder) 5018 if err == io.EOF { 5019 return out, metadata, nil 5020 } 5021 if err != nil { 5022 var snapshot bytes.Buffer 5023 io.Copy(&snapshot, ringBuffer) 5024 return out, metadata, &smithy.DeserializationError{ 5025 Err: fmt.Errorf("failed to decode response body, %w", err), 5026 Snapshot: snapshot.Bytes(), 5027 } 5028 } 5029 5030 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5031 t, err = decoder.GetElement("ModifyDBClusterEndpointResult") 5032 if err != nil { 5033 var snapshot bytes.Buffer 5034 io.Copy(&snapshot, ringBuffer) 5035 err = &smithy.DeserializationError{ 5036 Err: fmt.Errorf("failed to decode response body, %w", err), 5037 Snapshot: snapshot.Bytes(), 5038 } 5039 return out, metadata, err 5040 } 5041 5042 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5043 err = awsAwsquery_deserializeOpDocumentModifyDBClusterEndpointOutput(&output, decoder) 5044 if err != nil { 5045 var snapshot bytes.Buffer 5046 io.Copy(&snapshot, ringBuffer) 5047 err = &smithy.DeserializationError{ 5048 Err: fmt.Errorf("failed to decode response body, %w", err), 5049 Snapshot: snapshot.Bytes(), 5050 } 5051 return out, metadata, err 5052 } 5053 5054 return out, metadata, err 5055} 5056 5057func awsAwsquery_deserializeOpErrorModifyDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5058 var errorBuffer bytes.Buffer 5059 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5060 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5061 } 5062 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5063 5064 errorCode := "UnknownError" 5065 errorMessage := errorCode 5066 5067 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5068 if err != nil { 5069 return err 5070 } 5071 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5072 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5073 } 5074 if len(errorComponents.Code) != 0 { 5075 errorCode = errorComponents.Code 5076 } 5077 if len(errorComponents.Message) != 0 { 5078 errorMessage = errorComponents.Message 5079 } 5080 errorBody.Seek(0, io.SeekStart) 5081 switch { 5082 case strings.EqualFold("DBClusterEndpointNotFoundFault", errorCode): 5083 return awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response, errorBody) 5084 5085 case strings.EqualFold("DBInstanceNotFound", errorCode): 5086 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 5087 5088 case strings.EqualFold("InvalidDBClusterEndpointStateFault", errorCode): 5089 return awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response, errorBody) 5090 5091 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 5092 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 5093 5094 case strings.EqualFold("InvalidDBInstanceState", errorCode): 5095 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 5096 5097 default: 5098 genericError := &smithy.GenericAPIError{ 5099 Code: errorCode, 5100 Message: errorMessage, 5101 } 5102 return genericError 5103 5104 } 5105} 5106 5107type awsAwsquery_deserializeOpModifyDBClusterParameterGroup struct { 5108} 5109 5110func (*awsAwsquery_deserializeOpModifyDBClusterParameterGroup) ID() string { 5111 return "OperationDeserializer" 5112} 5113 5114func (m *awsAwsquery_deserializeOpModifyDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5115 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5116) { 5117 out, metadata, err = next.HandleDeserialize(ctx, in) 5118 if err != nil { 5119 return out, metadata, err 5120 } 5121 5122 response, ok := out.RawResponse.(*smithyhttp.Response) 5123 if !ok { 5124 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5125 } 5126 5127 if response.StatusCode < 200 || response.StatusCode >= 300 { 5128 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBClusterParameterGroup(response, &metadata) 5129 } 5130 output := &ModifyDBClusterParameterGroupOutput{} 5131 out.Result = output 5132 5133 var buff [1024]byte 5134 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5135 body := io.TeeReader(response.Body, ringBuffer) 5136 rootDecoder := xml.NewDecoder(body) 5137 t, err := smithyxml.FetchRootElement(rootDecoder) 5138 if err == io.EOF { 5139 return out, metadata, nil 5140 } 5141 if err != nil { 5142 var snapshot bytes.Buffer 5143 io.Copy(&snapshot, ringBuffer) 5144 return out, metadata, &smithy.DeserializationError{ 5145 Err: fmt.Errorf("failed to decode response body, %w", err), 5146 Snapshot: snapshot.Bytes(), 5147 } 5148 } 5149 5150 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5151 t, err = decoder.GetElement("ModifyDBClusterParameterGroupResult") 5152 if err != nil { 5153 var snapshot bytes.Buffer 5154 io.Copy(&snapshot, ringBuffer) 5155 err = &smithy.DeserializationError{ 5156 Err: fmt.Errorf("failed to decode response body, %w", err), 5157 Snapshot: snapshot.Bytes(), 5158 } 5159 return out, metadata, err 5160 } 5161 5162 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5163 err = awsAwsquery_deserializeOpDocumentModifyDBClusterParameterGroupOutput(&output, decoder) 5164 if err != nil { 5165 var snapshot bytes.Buffer 5166 io.Copy(&snapshot, ringBuffer) 5167 err = &smithy.DeserializationError{ 5168 Err: fmt.Errorf("failed to decode response body, %w", err), 5169 Snapshot: snapshot.Bytes(), 5170 } 5171 return out, metadata, err 5172 } 5173 5174 return out, metadata, err 5175} 5176 5177func awsAwsquery_deserializeOpErrorModifyDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5178 var errorBuffer bytes.Buffer 5179 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5180 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5181 } 5182 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5183 5184 errorCode := "UnknownError" 5185 errorMessage := errorCode 5186 5187 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5188 if err != nil { 5189 return err 5190 } 5191 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5192 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5193 } 5194 if len(errorComponents.Code) != 0 { 5195 errorCode = errorComponents.Code 5196 } 5197 if len(errorComponents.Message) != 0 { 5198 errorMessage = errorComponents.Message 5199 } 5200 errorBody.Seek(0, io.SeekStart) 5201 switch { 5202 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 5203 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 5204 5205 case strings.EqualFold("InvalidDBParameterGroupState", errorCode): 5206 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 5207 5208 default: 5209 genericError := &smithy.GenericAPIError{ 5210 Code: errorCode, 5211 Message: errorMessage, 5212 } 5213 return genericError 5214 5215 } 5216} 5217 5218type awsAwsquery_deserializeOpModifyDBClusterSnapshotAttribute struct { 5219} 5220 5221func (*awsAwsquery_deserializeOpModifyDBClusterSnapshotAttribute) ID() string { 5222 return "OperationDeserializer" 5223} 5224 5225func (m *awsAwsquery_deserializeOpModifyDBClusterSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5226 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5227) { 5228 out, metadata, err = next.HandleDeserialize(ctx, in) 5229 if err != nil { 5230 return out, metadata, err 5231 } 5232 5233 response, ok := out.RawResponse.(*smithyhttp.Response) 5234 if !ok { 5235 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5236 } 5237 5238 if response.StatusCode < 200 || response.StatusCode >= 300 { 5239 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBClusterSnapshotAttribute(response, &metadata) 5240 } 5241 output := &ModifyDBClusterSnapshotAttributeOutput{} 5242 out.Result = output 5243 5244 var buff [1024]byte 5245 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5246 body := io.TeeReader(response.Body, ringBuffer) 5247 rootDecoder := xml.NewDecoder(body) 5248 t, err := smithyxml.FetchRootElement(rootDecoder) 5249 if err == io.EOF { 5250 return out, metadata, nil 5251 } 5252 if err != nil { 5253 var snapshot bytes.Buffer 5254 io.Copy(&snapshot, ringBuffer) 5255 return out, metadata, &smithy.DeserializationError{ 5256 Err: fmt.Errorf("failed to decode response body, %w", err), 5257 Snapshot: snapshot.Bytes(), 5258 } 5259 } 5260 5261 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5262 t, err = decoder.GetElement("ModifyDBClusterSnapshotAttributeResult") 5263 if err != nil { 5264 var snapshot bytes.Buffer 5265 io.Copy(&snapshot, ringBuffer) 5266 err = &smithy.DeserializationError{ 5267 Err: fmt.Errorf("failed to decode response body, %w", err), 5268 Snapshot: snapshot.Bytes(), 5269 } 5270 return out, metadata, err 5271 } 5272 5273 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5274 err = awsAwsquery_deserializeOpDocumentModifyDBClusterSnapshotAttributeOutput(&output, decoder) 5275 if err != nil { 5276 var snapshot bytes.Buffer 5277 io.Copy(&snapshot, ringBuffer) 5278 err = &smithy.DeserializationError{ 5279 Err: fmt.Errorf("failed to decode response body, %w", err), 5280 Snapshot: snapshot.Bytes(), 5281 } 5282 return out, metadata, err 5283 } 5284 5285 return out, metadata, err 5286} 5287 5288func awsAwsquery_deserializeOpErrorModifyDBClusterSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5289 var errorBuffer bytes.Buffer 5290 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5291 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5292 } 5293 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5294 5295 errorCode := "UnknownError" 5296 errorMessage := errorCode 5297 5298 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5299 if err != nil { 5300 return err 5301 } 5302 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5303 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5304 } 5305 if len(errorComponents.Code) != 0 { 5306 errorCode = errorComponents.Code 5307 } 5308 if len(errorComponents.Message) != 0 { 5309 errorMessage = errorComponents.Message 5310 } 5311 errorBody.Seek(0, io.SeekStart) 5312 switch { 5313 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 5314 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 5315 5316 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 5317 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 5318 5319 case strings.EqualFold("SharedSnapshotQuotaExceeded", errorCode): 5320 return awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response, errorBody) 5321 5322 default: 5323 genericError := &smithy.GenericAPIError{ 5324 Code: errorCode, 5325 Message: errorMessage, 5326 } 5327 return genericError 5328 5329 } 5330} 5331 5332type awsAwsquery_deserializeOpModifyDBInstance struct { 5333} 5334 5335func (*awsAwsquery_deserializeOpModifyDBInstance) ID() string { 5336 return "OperationDeserializer" 5337} 5338 5339func (m *awsAwsquery_deserializeOpModifyDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5340 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5341) { 5342 out, metadata, err = next.HandleDeserialize(ctx, in) 5343 if err != nil { 5344 return out, metadata, err 5345 } 5346 5347 response, ok := out.RawResponse.(*smithyhttp.Response) 5348 if !ok { 5349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5350 } 5351 5352 if response.StatusCode < 200 || response.StatusCode >= 300 { 5353 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBInstance(response, &metadata) 5354 } 5355 output := &ModifyDBInstanceOutput{} 5356 out.Result = output 5357 5358 var buff [1024]byte 5359 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5360 body := io.TeeReader(response.Body, ringBuffer) 5361 rootDecoder := xml.NewDecoder(body) 5362 t, err := smithyxml.FetchRootElement(rootDecoder) 5363 if err == io.EOF { 5364 return out, metadata, nil 5365 } 5366 if err != nil { 5367 var snapshot bytes.Buffer 5368 io.Copy(&snapshot, ringBuffer) 5369 return out, metadata, &smithy.DeserializationError{ 5370 Err: fmt.Errorf("failed to decode response body, %w", err), 5371 Snapshot: snapshot.Bytes(), 5372 } 5373 } 5374 5375 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5376 t, err = decoder.GetElement("ModifyDBInstanceResult") 5377 if err != nil { 5378 var snapshot bytes.Buffer 5379 io.Copy(&snapshot, ringBuffer) 5380 err = &smithy.DeserializationError{ 5381 Err: fmt.Errorf("failed to decode response body, %w", err), 5382 Snapshot: snapshot.Bytes(), 5383 } 5384 return out, metadata, err 5385 } 5386 5387 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5388 err = awsAwsquery_deserializeOpDocumentModifyDBInstanceOutput(&output, decoder) 5389 if err != nil { 5390 var snapshot bytes.Buffer 5391 io.Copy(&snapshot, ringBuffer) 5392 err = &smithy.DeserializationError{ 5393 Err: fmt.Errorf("failed to decode response body, %w", err), 5394 Snapshot: snapshot.Bytes(), 5395 } 5396 return out, metadata, err 5397 } 5398 5399 return out, metadata, err 5400} 5401 5402func awsAwsquery_deserializeOpErrorModifyDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5403 var errorBuffer bytes.Buffer 5404 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5405 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5406 } 5407 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5408 5409 errorCode := "UnknownError" 5410 errorMessage := errorCode 5411 5412 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5413 if err != nil { 5414 return err 5415 } 5416 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5417 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5418 } 5419 if len(errorComponents.Code) != 0 { 5420 errorCode = errorComponents.Code 5421 } 5422 if len(errorComponents.Message) != 0 { 5423 errorMessage = errorComponents.Message 5424 } 5425 errorBody.Seek(0, io.SeekStart) 5426 switch { 5427 case strings.EqualFold("AuthorizationNotFound", errorCode): 5428 return awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response, errorBody) 5429 5430 case strings.EqualFold("CertificateNotFound", errorCode): 5431 return awsAwsquery_deserializeErrorCertificateNotFoundFault(response, errorBody) 5432 5433 case strings.EqualFold("DBInstanceAlreadyExists", errorCode): 5434 return awsAwsquery_deserializeErrorDBInstanceAlreadyExistsFault(response, errorBody) 5435 5436 case strings.EqualFold("DBInstanceNotFound", errorCode): 5437 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 5438 5439 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 5440 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 5441 5442 case strings.EqualFold("DBSecurityGroupNotFound", errorCode): 5443 return awsAwsquery_deserializeErrorDBSecurityGroupNotFoundFault(response, errorBody) 5444 5445 case strings.EqualFold("DBUpgradeDependencyFailure", errorCode): 5446 return awsAwsquery_deserializeErrorDBUpgradeDependencyFailureFault(response, errorBody) 5447 5448 case strings.EqualFold("DomainNotFoundFault", errorCode): 5449 return awsAwsquery_deserializeErrorDomainNotFoundFault(response, errorBody) 5450 5451 case strings.EqualFold("InsufficientDBInstanceCapacity", errorCode): 5452 return awsAwsquery_deserializeErrorInsufficientDBInstanceCapacityFault(response, errorBody) 5453 5454 case strings.EqualFold("InvalidDBInstanceState", errorCode): 5455 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 5456 5457 case strings.EqualFold("InvalidDBSecurityGroupState", errorCode): 5458 return awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response, errorBody) 5459 5460 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 5461 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 5462 5463 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 5464 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 5465 5466 case strings.EqualFold("ProvisionedIopsNotAvailableInAZFault", errorCode): 5467 return awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response, errorBody) 5468 5469 case strings.EqualFold("StorageQuotaExceeded", errorCode): 5470 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 5471 5472 case strings.EqualFold("StorageTypeNotSupported", errorCode): 5473 return awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response, errorBody) 5474 5475 default: 5476 genericError := &smithy.GenericAPIError{ 5477 Code: errorCode, 5478 Message: errorMessage, 5479 } 5480 return genericError 5481 5482 } 5483} 5484 5485type awsAwsquery_deserializeOpModifyDBParameterGroup struct { 5486} 5487 5488func (*awsAwsquery_deserializeOpModifyDBParameterGroup) ID() string { 5489 return "OperationDeserializer" 5490} 5491 5492func (m *awsAwsquery_deserializeOpModifyDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5493 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5494) { 5495 out, metadata, err = next.HandleDeserialize(ctx, in) 5496 if err != nil { 5497 return out, metadata, err 5498 } 5499 5500 response, ok := out.RawResponse.(*smithyhttp.Response) 5501 if !ok { 5502 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5503 } 5504 5505 if response.StatusCode < 200 || response.StatusCode >= 300 { 5506 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBParameterGroup(response, &metadata) 5507 } 5508 output := &ModifyDBParameterGroupOutput{} 5509 out.Result = output 5510 5511 var buff [1024]byte 5512 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5513 body := io.TeeReader(response.Body, ringBuffer) 5514 rootDecoder := xml.NewDecoder(body) 5515 t, err := smithyxml.FetchRootElement(rootDecoder) 5516 if err == io.EOF { 5517 return out, metadata, nil 5518 } 5519 if err != nil { 5520 var snapshot bytes.Buffer 5521 io.Copy(&snapshot, ringBuffer) 5522 return out, metadata, &smithy.DeserializationError{ 5523 Err: fmt.Errorf("failed to decode response body, %w", err), 5524 Snapshot: snapshot.Bytes(), 5525 } 5526 } 5527 5528 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5529 t, err = decoder.GetElement("ModifyDBParameterGroupResult") 5530 if err != nil { 5531 var snapshot bytes.Buffer 5532 io.Copy(&snapshot, ringBuffer) 5533 err = &smithy.DeserializationError{ 5534 Err: fmt.Errorf("failed to decode response body, %w", err), 5535 Snapshot: snapshot.Bytes(), 5536 } 5537 return out, metadata, err 5538 } 5539 5540 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5541 err = awsAwsquery_deserializeOpDocumentModifyDBParameterGroupOutput(&output, decoder) 5542 if err != nil { 5543 var snapshot bytes.Buffer 5544 io.Copy(&snapshot, ringBuffer) 5545 err = &smithy.DeserializationError{ 5546 Err: fmt.Errorf("failed to decode response body, %w", err), 5547 Snapshot: snapshot.Bytes(), 5548 } 5549 return out, metadata, err 5550 } 5551 5552 return out, metadata, err 5553} 5554 5555func awsAwsquery_deserializeOpErrorModifyDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5556 var errorBuffer bytes.Buffer 5557 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5558 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5559 } 5560 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5561 5562 errorCode := "UnknownError" 5563 errorMessage := errorCode 5564 5565 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5566 if err != nil { 5567 return err 5568 } 5569 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5570 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5571 } 5572 if len(errorComponents.Code) != 0 { 5573 errorCode = errorComponents.Code 5574 } 5575 if len(errorComponents.Message) != 0 { 5576 errorMessage = errorComponents.Message 5577 } 5578 errorBody.Seek(0, io.SeekStart) 5579 switch { 5580 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 5581 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 5582 5583 case strings.EqualFold("InvalidDBParameterGroupState", errorCode): 5584 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 5585 5586 default: 5587 genericError := &smithy.GenericAPIError{ 5588 Code: errorCode, 5589 Message: errorMessage, 5590 } 5591 return genericError 5592 5593 } 5594} 5595 5596type awsAwsquery_deserializeOpModifyDBSubnetGroup struct { 5597} 5598 5599func (*awsAwsquery_deserializeOpModifyDBSubnetGroup) ID() string { 5600 return "OperationDeserializer" 5601} 5602 5603func (m *awsAwsquery_deserializeOpModifyDBSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5604 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5605) { 5606 out, metadata, err = next.HandleDeserialize(ctx, in) 5607 if err != nil { 5608 return out, metadata, err 5609 } 5610 5611 response, ok := out.RawResponse.(*smithyhttp.Response) 5612 if !ok { 5613 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5614 } 5615 5616 if response.StatusCode < 200 || response.StatusCode >= 300 { 5617 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBSubnetGroup(response, &metadata) 5618 } 5619 output := &ModifyDBSubnetGroupOutput{} 5620 out.Result = output 5621 5622 var buff [1024]byte 5623 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5624 body := io.TeeReader(response.Body, ringBuffer) 5625 rootDecoder := xml.NewDecoder(body) 5626 t, err := smithyxml.FetchRootElement(rootDecoder) 5627 if err == io.EOF { 5628 return out, metadata, nil 5629 } 5630 if err != nil { 5631 var snapshot bytes.Buffer 5632 io.Copy(&snapshot, ringBuffer) 5633 return out, metadata, &smithy.DeserializationError{ 5634 Err: fmt.Errorf("failed to decode response body, %w", err), 5635 Snapshot: snapshot.Bytes(), 5636 } 5637 } 5638 5639 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5640 t, err = decoder.GetElement("ModifyDBSubnetGroupResult") 5641 if err != nil { 5642 var snapshot bytes.Buffer 5643 io.Copy(&snapshot, ringBuffer) 5644 err = &smithy.DeserializationError{ 5645 Err: fmt.Errorf("failed to decode response body, %w", err), 5646 Snapshot: snapshot.Bytes(), 5647 } 5648 return out, metadata, err 5649 } 5650 5651 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5652 err = awsAwsquery_deserializeOpDocumentModifyDBSubnetGroupOutput(&output, decoder) 5653 if err != nil { 5654 var snapshot bytes.Buffer 5655 io.Copy(&snapshot, ringBuffer) 5656 err = &smithy.DeserializationError{ 5657 Err: fmt.Errorf("failed to decode response body, %w", err), 5658 Snapshot: snapshot.Bytes(), 5659 } 5660 return out, metadata, err 5661 } 5662 5663 return out, metadata, err 5664} 5665 5666func awsAwsquery_deserializeOpErrorModifyDBSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5667 var errorBuffer bytes.Buffer 5668 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5669 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5670 } 5671 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5672 5673 errorCode := "UnknownError" 5674 errorMessage := errorCode 5675 5676 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5677 if err != nil { 5678 return err 5679 } 5680 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5681 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5682 } 5683 if len(errorComponents.Code) != 0 { 5684 errorCode = errorComponents.Code 5685 } 5686 if len(errorComponents.Message) != 0 { 5687 errorMessage = errorComponents.Message 5688 } 5689 errorBody.Seek(0, io.SeekStart) 5690 switch { 5691 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 5692 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 5693 5694 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 5695 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 5696 5697 case strings.EqualFold("DBSubnetQuotaExceededFault", errorCode): 5698 return awsAwsquery_deserializeErrorDBSubnetQuotaExceededFault(response, errorBody) 5699 5700 case strings.EqualFold("InvalidSubnet", errorCode): 5701 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 5702 5703 case strings.EqualFold("SubnetAlreadyInUse", errorCode): 5704 return awsAwsquery_deserializeErrorSubnetAlreadyInUse(response, errorBody) 5705 5706 default: 5707 genericError := &smithy.GenericAPIError{ 5708 Code: errorCode, 5709 Message: errorMessage, 5710 } 5711 return genericError 5712 5713 } 5714} 5715 5716type awsAwsquery_deserializeOpModifyEventSubscription struct { 5717} 5718 5719func (*awsAwsquery_deserializeOpModifyEventSubscription) ID() string { 5720 return "OperationDeserializer" 5721} 5722 5723func (m *awsAwsquery_deserializeOpModifyEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5724 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5725) { 5726 out, metadata, err = next.HandleDeserialize(ctx, in) 5727 if err != nil { 5728 return out, metadata, err 5729 } 5730 5731 response, ok := out.RawResponse.(*smithyhttp.Response) 5732 if !ok { 5733 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5734 } 5735 5736 if response.StatusCode < 200 || response.StatusCode >= 300 { 5737 return out, metadata, awsAwsquery_deserializeOpErrorModifyEventSubscription(response, &metadata) 5738 } 5739 output := &ModifyEventSubscriptionOutput{} 5740 out.Result = output 5741 5742 var buff [1024]byte 5743 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5744 body := io.TeeReader(response.Body, ringBuffer) 5745 rootDecoder := xml.NewDecoder(body) 5746 t, err := smithyxml.FetchRootElement(rootDecoder) 5747 if err == io.EOF { 5748 return out, metadata, nil 5749 } 5750 if err != nil { 5751 var snapshot bytes.Buffer 5752 io.Copy(&snapshot, ringBuffer) 5753 return out, metadata, &smithy.DeserializationError{ 5754 Err: fmt.Errorf("failed to decode response body, %w", err), 5755 Snapshot: snapshot.Bytes(), 5756 } 5757 } 5758 5759 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5760 t, err = decoder.GetElement("ModifyEventSubscriptionResult") 5761 if err != nil { 5762 var snapshot bytes.Buffer 5763 io.Copy(&snapshot, ringBuffer) 5764 err = &smithy.DeserializationError{ 5765 Err: fmt.Errorf("failed to decode response body, %w", err), 5766 Snapshot: snapshot.Bytes(), 5767 } 5768 return out, metadata, err 5769 } 5770 5771 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5772 err = awsAwsquery_deserializeOpDocumentModifyEventSubscriptionOutput(&output, decoder) 5773 if err != nil { 5774 var snapshot bytes.Buffer 5775 io.Copy(&snapshot, ringBuffer) 5776 err = &smithy.DeserializationError{ 5777 Err: fmt.Errorf("failed to decode response body, %w", err), 5778 Snapshot: snapshot.Bytes(), 5779 } 5780 return out, metadata, err 5781 } 5782 5783 return out, metadata, err 5784} 5785 5786func awsAwsquery_deserializeOpErrorModifyEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5787 var errorBuffer bytes.Buffer 5788 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5789 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5790 } 5791 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5792 5793 errorCode := "UnknownError" 5794 errorMessage := errorCode 5795 5796 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5797 if err != nil { 5798 return err 5799 } 5800 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5801 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5802 } 5803 if len(errorComponents.Code) != 0 { 5804 errorCode = errorComponents.Code 5805 } 5806 if len(errorComponents.Message) != 0 { 5807 errorMessage = errorComponents.Message 5808 } 5809 errorBody.Seek(0, io.SeekStart) 5810 switch { 5811 case strings.EqualFold("EventSubscriptionQuotaExceeded", errorCode): 5812 return awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response, errorBody) 5813 5814 case strings.EqualFold("SNSInvalidTopic", errorCode): 5815 return awsAwsquery_deserializeErrorSNSInvalidTopicFault(response, errorBody) 5816 5817 case strings.EqualFold("SNSNoAuthorization", errorCode): 5818 return awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response, errorBody) 5819 5820 case strings.EqualFold("SNSTopicArnNotFound", errorCode): 5821 return awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response, errorBody) 5822 5823 case strings.EqualFold("SubscriptionCategoryNotFound", errorCode): 5824 return awsAwsquery_deserializeErrorSubscriptionCategoryNotFoundFault(response, errorBody) 5825 5826 case strings.EqualFold("SubscriptionNotFound", errorCode): 5827 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 5828 5829 default: 5830 genericError := &smithy.GenericAPIError{ 5831 Code: errorCode, 5832 Message: errorMessage, 5833 } 5834 return genericError 5835 5836 } 5837} 5838 5839type awsAwsquery_deserializeOpPromoteReadReplicaDBCluster struct { 5840} 5841 5842func (*awsAwsquery_deserializeOpPromoteReadReplicaDBCluster) ID() string { 5843 return "OperationDeserializer" 5844} 5845 5846func (m *awsAwsquery_deserializeOpPromoteReadReplicaDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5847 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5848) { 5849 out, metadata, err = next.HandleDeserialize(ctx, in) 5850 if err != nil { 5851 return out, metadata, err 5852 } 5853 5854 response, ok := out.RawResponse.(*smithyhttp.Response) 5855 if !ok { 5856 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5857 } 5858 5859 if response.StatusCode < 200 || response.StatusCode >= 300 { 5860 return out, metadata, awsAwsquery_deserializeOpErrorPromoteReadReplicaDBCluster(response, &metadata) 5861 } 5862 output := &PromoteReadReplicaDBClusterOutput{} 5863 out.Result = output 5864 5865 var buff [1024]byte 5866 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5867 body := io.TeeReader(response.Body, ringBuffer) 5868 rootDecoder := xml.NewDecoder(body) 5869 t, err := smithyxml.FetchRootElement(rootDecoder) 5870 if err == io.EOF { 5871 return out, metadata, nil 5872 } 5873 if err != nil { 5874 var snapshot bytes.Buffer 5875 io.Copy(&snapshot, ringBuffer) 5876 return out, metadata, &smithy.DeserializationError{ 5877 Err: fmt.Errorf("failed to decode response body, %w", err), 5878 Snapshot: snapshot.Bytes(), 5879 } 5880 } 5881 5882 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5883 t, err = decoder.GetElement("PromoteReadReplicaDBClusterResult") 5884 if err != nil { 5885 var snapshot bytes.Buffer 5886 io.Copy(&snapshot, ringBuffer) 5887 err = &smithy.DeserializationError{ 5888 Err: fmt.Errorf("failed to decode response body, %w", err), 5889 Snapshot: snapshot.Bytes(), 5890 } 5891 return out, metadata, err 5892 } 5893 5894 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5895 err = awsAwsquery_deserializeOpDocumentPromoteReadReplicaDBClusterOutput(&output, decoder) 5896 if err != nil { 5897 var snapshot bytes.Buffer 5898 io.Copy(&snapshot, ringBuffer) 5899 err = &smithy.DeserializationError{ 5900 Err: fmt.Errorf("failed to decode response body, %w", err), 5901 Snapshot: snapshot.Bytes(), 5902 } 5903 return out, metadata, err 5904 } 5905 5906 return out, metadata, err 5907} 5908 5909func awsAwsquery_deserializeOpErrorPromoteReadReplicaDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5910 var errorBuffer bytes.Buffer 5911 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5912 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5913 } 5914 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5915 5916 errorCode := "UnknownError" 5917 errorMessage := errorCode 5918 5919 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5920 if err != nil { 5921 return err 5922 } 5923 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5924 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5925 } 5926 if len(errorComponents.Code) != 0 { 5927 errorCode = errorComponents.Code 5928 } 5929 if len(errorComponents.Message) != 0 { 5930 errorMessage = errorComponents.Message 5931 } 5932 errorBody.Seek(0, io.SeekStart) 5933 switch { 5934 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 5935 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 5936 5937 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 5938 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 5939 5940 default: 5941 genericError := &smithy.GenericAPIError{ 5942 Code: errorCode, 5943 Message: errorMessage, 5944 } 5945 return genericError 5946 5947 } 5948} 5949 5950type awsAwsquery_deserializeOpRebootDBInstance struct { 5951} 5952 5953func (*awsAwsquery_deserializeOpRebootDBInstance) ID() string { 5954 return "OperationDeserializer" 5955} 5956 5957func (m *awsAwsquery_deserializeOpRebootDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5958 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5959) { 5960 out, metadata, err = next.HandleDeserialize(ctx, in) 5961 if err != nil { 5962 return out, metadata, err 5963 } 5964 5965 response, ok := out.RawResponse.(*smithyhttp.Response) 5966 if !ok { 5967 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5968 } 5969 5970 if response.StatusCode < 200 || response.StatusCode >= 300 { 5971 return out, metadata, awsAwsquery_deserializeOpErrorRebootDBInstance(response, &metadata) 5972 } 5973 output := &RebootDBInstanceOutput{} 5974 out.Result = output 5975 5976 var buff [1024]byte 5977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5978 body := io.TeeReader(response.Body, ringBuffer) 5979 rootDecoder := xml.NewDecoder(body) 5980 t, err := smithyxml.FetchRootElement(rootDecoder) 5981 if err == io.EOF { 5982 return out, metadata, nil 5983 } 5984 if err != nil { 5985 var snapshot bytes.Buffer 5986 io.Copy(&snapshot, ringBuffer) 5987 return out, metadata, &smithy.DeserializationError{ 5988 Err: fmt.Errorf("failed to decode response body, %w", err), 5989 Snapshot: snapshot.Bytes(), 5990 } 5991 } 5992 5993 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5994 t, err = decoder.GetElement("RebootDBInstanceResult") 5995 if err != nil { 5996 var snapshot bytes.Buffer 5997 io.Copy(&snapshot, ringBuffer) 5998 err = &smithy.DeserializationError{ 5999 Err: fmt.Errorf("failed to decode response body, %w", err), 6000 Snapshot: snapshot.Bytes(), 6001 } 6002 return out, metadata, err 6003 } 6004 6005 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6006 err = awsAwsquery_deserializeOpDocumentRebootDBInstanceOutput(&output, decoder) 6007 if err != nil { 6008 var snapshot bytes.Buffer 6009 io.Copy(&snapshot, ringBuffer) 6010 err = &smithy.DeserializationError{ 6011 Err: fmt.Errorf("failed to decode response body, %w", err), 6012 Snapshot: snapshot.Bytes(), 6013 } 6014 return out, metadata, err 6015 } 6016 6017 return out, metadata, err 6018} 6019 6020func awsAwsquery_deserializeOpErrorRebootDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6021 var errorBuffer bytes.Buffer 6022 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6023 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6024 } 6025 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6026 6027 errorCode := "UnknownError" 6028 errorMessage := errorCode 6029 6030 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6031 if err != nil { 6032 return err 6033 } 6034 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6035 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6036 } 6037 if len(errorComponents.Code) != 0 { 6038 errorCode = errorComponents.Code 6039 } 6040 if len(errorComponents.Message) != 0 { 6041 errorMessage = errorComponents.Message 6042 } 6043 errorBody.Seek(0, io.SeekStart) 6044 switch { 6045 case strings.EqualFold("DBInstanceNotFound", errorCode): 6046 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 6047 6048 case strings.EqualFold("InvalidDBInstanceState", errorCode): 6049 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 6050 6051 default: 6052 genericError := &smithy.GenericAPIError{ 6053 Code: errorCode, 6054 Message: errorMessage, 6055 } 6056 return genericError 6057 6058 } 6059} 6060 6061type awsAwsquery_deserializeOpRemoveRoleFromDBCluster struct { 6062} 6063 6064func (*awsAwsquery_deserializeOpRemoveRoleFromDBCluster) ID() string { 6065 return "OperationDeserializer" 6066} 6067 6068func (m *awsAwsquery_deserializeOpRemoveRoleFromDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6069 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6070) { 6071 out, metadata, err = next.HandleDeserialize(ctx, in) 6072 if err != nil { 6073 return out, metadata, err 6074 } 6075 6076 response, ok := out.RawResponse.(*smithyhttp.Response) 6077 if !ok { 6078 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6079 } 6080 6081 if response.StatusCode < 200 || response.StatusCode >= 300 { 6082 return out, metadata, awsAwsquery_deserializeOpErrorRemoveRoleFromDBCluster(response, &metadata) 6083 } 6084 output := &RemoveRoleFromDBClusterOutput{} 6085 out.Result = output 6086 6087 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 6088 return out, metadata, &smithy.DeserializationError{ 6089 Err: fmt.Errorf("failed to discard response body, %w", err), 6090 } 6091 } 6092 6093 return out, metadata, err 6094} 6095 6096func awsAwsquery_deserializeOpErrorRemoveRoleFromDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6097 var errorBuffer bytes.Buffer 6098 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6099 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6100 } 6101 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6102 6103 errorCode := "UnknownError" 6104 errorMessage := errorCode 6105 6106 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6107 if err != nil { 6108 return err 6109 } 6110 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6111 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6112 } 6113 if len(errorComponents.Code) != 0 { 6114 errorCode = errorComponents.Code 6115 } 6116 if len(errorComponents.Message) != 0 { 6117 errorMessage = errorComponents.Message 6118 } 6119 errorBody.Seek(0, io.SeekStart) 6120 switch { 6121 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6122 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6123 6124 case strings.EqualFold("DBClusterRoleNotFound", errorCode): 6125 return awsAwsquery_deserializeErrorDBClusterRoleNotFoundFault(response, errorBody) 6126 6127 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 6128 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 6129 6130 default: 6131 genericError := &smithy.GenericAPIError{ 6132 Code: errorCode, 6133 Message: errorMessage, 6134 } 6135 return genericError 6136 6137 } 6138} 6139 6140type awsAwsquery_deserializeOpRemoveSourceIdentifierFromSubscription struct { 6141} 6142 6143func (*awsAwsquery_deserializeOpRemoveSourceIdentifierFromSubscription) ID() string { 6144 return "OperationDeserializer" 6145} 6146 6147func (m *awsAwsquery_deserializeOpRemoveSourceIdentifierFromSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6148 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6149) { 6150 out, metadata, err = next.HandleDeserialize(ctx, in) 6151 if err != nil { 6152 return out, metadata, err 6153 } 6154 6155 response, ok := out.RawResponse.(*smithyhttp.Response) 6156 if !ok { 6157 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6158 } 6159 6160 if response.StatusCode < 200 || response.StatusCode >= 300 { 6161 return out, metadata, awsAwsquery_deserializeOpErrorRemoveSourceIdentifierFromSubscription(response, &metadata) 6162 } 6163 output := &RemoveSourceIdentifierFromSubscriptionOutput{} 6164 out.Result = output 6165 6166 var buff [1024]byte 6167 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6168 body := io.TeeReader(response.Body, ringBuffer) 6169 rootDecoder := xml.NewDecoder(body) 6170 t, err := smithyxml.FetchRootElement(rootDecoder) 6171 if err == io.EOF { 6172 return out, metadata, nil 6173 } 6174 if err != nil { 6175 var snapshot bytes.Buffer 6176 io.Copy(&snapshot, ringBuffer) 6177 return out, metadata, &smithy.DeserializationError{ 6178 Err: fmt.Errorf("failed to decode response body, %w", err), 6179 Snapshot: snapshot.Bytes(), 6180 } 6181 } 6182 6183 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6184 t, err = decoder.GetElement("RemoveSourceIdentifierFromSubscriptionResult") 6185 if err != nil { 6186 var snapshot bytes.Buffer 6187 io.Copy(&snapshot, ringBuffer) 6188 err = &smithy.DeserializationError{ 6189 Err: fmt.Errorf("failed to decode response body, %w", err), 6190 Snapshot: snapshot.Bytes(), 6191 } 6192 return out, metadata, err 6193 } 6194 6195 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6196 err = awsAwsquery_deserializeOpDocumentRemoveSourceIdentifierFromSubscriptionOutput(&output, decoder) 6197 if err != nil { 6198 var snapshot bytes.Buffer 6199 io.Copy(&snapshot, ringBuffer) 6200 err = &smithy.DeserializationError{ 6201 Err: fmt.Errorf("failed to decode response body, %w", err), 6202 Snapshot: snapshot.Bytes(), 6203 } 6204 return out, metadata, err 6205 } 6206 6207 return out, metadata, err 6208} 6209 6210func awsAwsquery_deserializeOpErrorRemoveSourceIdentifierFromSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6211 var errorBuffer bytes.Buffer 6212 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6213 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6214 } 6215 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6216 6217 errorCode := "UnknownError" 6218 errorMessage := errorCode 6219 6220 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6221 if err != nil { 6222 return err 6223 } 6224 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6225 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6226 } 6227 if len(errorComponents.Code) != 0 { 6228 errorCode = errorComponents.Code 6229 } 6230 if len(errorComponents.Message) != 0 { 6231 errorMessage = errorComponents.Message 6232 } 6233 errorBody.Seek(0, io.SeekStart) 6234 switch { 6235 case strings.EqualFold("SourceNotFound", errorCode): 6236 return awsAwsquery_deserializeErrorSourceNotFoundFault(response, errorBody) 6237 6238 case strings.EqualFold("SubscriptionNotFound", errorCode): 6239 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 6240 6241 default: 6242 genericError := &smithy.GenericAPIError{ 6243 Code: errorCode, 6244 Message: errorMessage, 6245 } 6246 return genericError 6247 6248 } 6249} 6250 6251type awsAwsquery_deserializeOpRemoveTagsFromResource struct { 6252} 6253 6254func (*awsAwsquery_deserializeOpRemoveTagsFromResource) ID() string { 6255 return "OperationDeserializer" 6256} 6257 6258func (m *awsAwsquery_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6259 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6260) { 6261 out, metadata, err = next.HandleDeserialize(ctx, in) 6262 if err != nil { 6263 return out, metadata, err 6264 } 6265 6266 response, ok := out.RawResponse.(*smithyhttp.Response) 6267 if !ok { 6268 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6269 } 6270 6271 if response.StatusCode < 200 || response.StatusCode >= 300 { 6272 return out, metadata, awsAwsquery_deserializeOpErrorRemoveTagsFromResource(response, &metadata) 6273 } 6274 output := &RemoveTagsFromResourceOutput{} 6275 out.Result = output 6276 6277 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 6278 return out, metadata, &smithy.DeserializationError{ 6279 Err: fmt.Errorf("failed to discard response body, %w", err), 6280 } 6281 } 6282 6283 return out, metadata, err 6284} 6285 6286func awsAwsquery_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6287 var errorBuffer bytes.Buffer 6288 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6289 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6290 } 6291 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6292 6293 errorCode := "UnknownError" 6294 errorMessage := errorCode 6295 6296 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6297 if err != nil { 6298 return err 6299 } 6300 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6301 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6302 } 6303 if len(errorComponents.Code) != 0 { 6304 errorCode = errorComponents.Code 6305 } 6306 if len(errorComponents.Message) != 0 { 6307 errorMessage = errorComponents.Message 6308 } 6309 errorBody.Seek(0, io.SeekStart) 6310 switch { 6311 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6312 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6313 6314 case strings.EqualFold("DBInstanceNotFound", errorCode): 6315 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 6316 6317 case strings.EqualFold("DBSnapshotNotFound", errorCode): 6318 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 6319 6320 default: 6321 genericError := &smithy.GenericAPIError{ 6322 Code: errorCode, 6323 Message: errorMessage, 6324 } 6325 return genericError 6326 6327 } 6328} 6329 6330type awsAwsquery_deserializeOpResetDBClusterParameterGroup struct { 6331} 6332 6333func (*awsAwsquery_deserializeOpResetDBClusterParameterGroup) ID() string { 6334 return "OperationDeserializer" 6335} 6336 6337func (m *awsAwsquery_deserializeOpResetDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6338 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6339) { 6340 out, metadata, err = next.HandleDeserialize(ctx, in) 6341 if err != nil { 6342 return out, metadata, err 6343 } 6344 6345 response, ok := out.RawResponse.(*smithyhttp.Response) 6346 if !ok { 6347 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6348 } 6349 6350 if response.StatusCode < 200 || response.StatusCode >= 300 { 6351 return out, metadata, awsAwsquery_deserializeOpErrorResetDBClusterParameterGroup(response, &metadata) 6352 } 6353 output := &ResetDBClusterParameterGroupOutput{} 6354 out.Result = output 6355 6356 var buff [1024]byte 6357 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6358 body := io.TeeReader(response.Body, ringBuffer) 6359 rootDecoder := xml.NewDecoder(body) 6360 t, err := smithyxml.FetchRootElement(rootDecoder) 6361 if err == io.EOF { 6362 return out, metadata, nil 6363 } 6364 if err != nil { 6365 var snapshot bytes.Buffer 6366 io.Copy(&snapshot, ringBuffer) 6367 return out, metadata, &smithy.DeserializationError{ 6368 Err: fmt.Errorf("failed to decode response body, %w", err), 6369 Snapshot: snapshot.Bytes(), 6370 } 6371 } 6372 6373 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6374 t, err = decoder.GetElement("ResetDBClusterParameterGroupResult") 6375 if err != nil { 6376 var snapshot bytes.Buffer 6377 io.Copy(&snapshot, ringBuffer) 6378 err = &smithy.DeserializationError{ 6379 Err: fmt.Errorf("failed to decode response body, %w", err), 6380 Snapshot: snapshot.Bytes(), 6381 } 6382 return out, metadata, err 6383 } 6384 6385 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6386 err = awsAwsquery_deserializeOpDocumentResetDBClusterParameterGroupOutput(&output, decoder) 6387 if err != nil { 6388 var snapshot bytes.Buffer 6389 io.Copy(&snapshot, ringBuffer) 6390 err = &smithy.DeserializationError{ 6391 Err: fmt.Errorf("failed to decode response body, %w", err), 6392 Snapshot: snapshot.Bytes(), 6393 } 6394 return out, metadata, err 6395 } 6396 6397 return out, metadata, err 6398} 6399 6400func awsAwsquery_deserializeOpErrorResetDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6401 var errorBuffer bytes.Buffer 6402 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6403 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6404 } 6405 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6406 6407 errorCode := "UnknownError" 6408 errorMessage := errorCode 6409 6410 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6411 if err != nil { 6412 return err 6413 } 6414 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6415 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6416 } 6417 if len(errorComponents.Code) != 0 { 6418 errorCode = errorComponents.Code 6419 } 6420 if len(errorComponents.Message) != 0 { 6421 errorMessage = errorComponents.Message 6422 } 6423 errorBody.Seek(0, io.SeekStart) 6424 switch { 6425 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 6426 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 6427 6428 case strings.EqualFold("InvalidDBParameterGroupState", errorCode): 6429 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 6430 6431 default: 6432 genericError := &smithy.GenericAPIError{ 6433 Code: errorCode, 6434 Message: errorMessage, 6435 } 6436 return genericError 6437 6438 } 6439} 6440 6441type awsAwsquery_deserializeOpResetDBParameterGroup struct { 6442} 6443 6444func (*awsAwsquery_deserializeOpResetDBParameterGroup) ID() string { 6445 return "OperationDeserializer" 6446} 6447 6448func (m *awsAwsquery_deserializeOpResetDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6449 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6450) { 6451 out, metadata, err = next.HandleDeserialize(ctx, in) 6452 if err != nil { 6453 return out, metadata, err 6454 } 6455 6456 response, ok := out.RawResponse.(*smithyhttp.Response) 6457 if !ok { 6458 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6459 } 6460 6461 if response.StatusCode < 200 || response.StatusCode >= 300 { 6462 return out, metadata, awsAwsquery_deserializeOpErrorResetDBParameterGroup(response, &metadata) 6463 } 6464 output := &ResetDBParameterGroupOutput{} 6465 out.Result = output 6466 6467 var buff [1024]byte 6468 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6469 body := io.TeeReader(response.Body, ringBuffer) 6470 rootDecoder := xml.NewDecoder(body) 6471 t, err := smithyxml.FetchRootElement(rootDecoder) 6472 if err == io.EOF { 6473 return out, metadata, nil 6474 } 6475 if err != nil { 6476 var snapshot bytes.Buffer 6477 io.Copy(&snapshot, ringBuffer) 6478 return out, metadata, &smithy.DeserializationError{ 6479 Err: fmt.Errorf("failed to decode response body, %w", err), 6480 Snapshot: snapshot.Bytes(), 6481 } 6482 } 6483 6484 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6485 t, err = decoder.GetElement("ResetDBParameterGroupResult") 6486 if err != nil { 6487 var snapshot bytes.Buffer 6488 io.Copy(&snapshot, ringBuffer) 6489 err = &smithy.DeserializationError{ 6490 Err: fmt.Errorf("failed to decode response body, %w", err), 6491 Snapshot: snapshot.Bytes(), 6492 } 6493 return out, metadata, err 6494 } 6495 6496 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6497 err = awsAwsquery_deserializeOpDocumentResetDBParameterGroupOutput(&output, decoder) 6498 if err != nil { 6499 var snapshot bytes.Buffer 6500 io.Copy(&snapshot, ringBuffer) 6501 err = &smithy.DeserializationError{ 6502 Err: fmt.Errorf("failed to decode response body, %w", err), 6503 Snapshot: snapshot.Bytes(), 6504 } 6505 return out, metadata, err 6506 } 6507 6508 return out, metadata, err 6509} 6510 6511func awsAwsquery_deserializeOpErrorResetDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6512 var errorBuffer bytes.Buffer 6513 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6514 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6515 } 6516 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6517 6518 errorCode := "UnknownError" 6519 errorMessage := errorCode 6520 6521 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6522 if err != nil { 6523 return err 6524 } 6525 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6526 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6527 } 6528 if len(errorComponents.Code) != 0 { 6529 errorCode = errorComponents.Code 6530 } 6531 if len(errorComponents.Message) != 0 { 6532 errorMessage = errorComponents.Message 6533 } 6534 errorBody.Seek(0, io.SeekStart) 6535 switch { 6536 case strings.EqualFold("DBParameterGroupNotFound", errorCode): 6537 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 6538 6539 case strings.EqualFold("InvalidDBParameterGroupState", errorCode): 6540 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 6541 6542 default: 6543 genericError := &smithy.GenericAPIError{ 6544 Code: errorCode, 6545 Message: errorMessage, 6546 } 6547 return genericError 6548 6549 } 6550} 6551 6552type awsAwsquery_deserializeOpRestoreDBClusterFromSnapshot struct { 6553} 6554 6555func (*awsAwsquery_deserializeOpRestoreDBClusterFromSnapshot) ID() string { 6556 return "OperationDeserializer" 6557} 6558 6559func (m *awsAwsquery_deserializeOpRestoreDBClusterFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6560 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6561) { 6562 out, metadata, err = next.HandleDeserialize(ctx, in) 6563 if err != nil { 6564 return out, metadata, err 6565 } 6566 6567 response, ok := out.RawResponse.(*smithyhttp.Response) 6568 if !ok { 6569 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6570 } 6571 6572 if response.StatusCode < 200 || response.StatusCode >= 300 { 6573 return out, metadata, awsAwsquery_deserializeOpErrorRestoreDBClusterFromSnapshot(response, &metadata) 6574 } 6575 output := &RestoreDBClusterFromSnapshotOutput{} 6576 out.Result = output 6577 6578 var buff [1024]byte 6579 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6580 body := io.TeeReader(response.Body, ringBuffer) 6581 rootDecoder := xml.NewDecoder(body) 6582 t, err := smithyxml.FetchRootElement(rootDecoder) 6583 if err == io.EOF { 6584 return out, metadata, nil 6585 } 6586 if err != nil { 6587 var snapshot bytes.Buffer 6588 io.Copy(&snapshot, ringBuffer) 6589 return out, metadata, &smithy.DeserializationError{ 6590 Err: fmt.Errorf("failed to decode response body, %w", err), 6591 Snapshot: snapshot.Bytes(), 6592 } 6593 } 6594 6595 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6596 t, err = decoder.GetElement("RestoreDBClusterFromSnapshotResult") 6597 if err != nil { 6598 var snapshot bytes.Buffer 6599 io.Copy(&snapshot, ringBuffer) 6600 err = &smithy.DeserializationError{ 6601 Err: fmt.Errorf("failed to decode response body, %w", err), 6602 Snapshot: snapshot.Bytes(), 6603 } 6604 return out, metadata, err 6605 } 6606 6607 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6608 err = awsAwsquery_deserializeOpDocumentRestoreDBClusterFromSnapshotOutput(&output, decoder) 6609 if err != nil { 6610 var snapshot bytes.Buffer 6611 io.Copy(&snapshot, ringBuffer) 6612 err = &smithy.DeserializationError{ 6613 Err: fmt.Errorf("failed to decode response body, %w", err), 6614 Snapshot: snapshot.Bytes(), 6615 } 6616 return out, metadata, err 6617 } 6618 6619 return out, metadata, err 6620} 6621 6622func awsAwsquery_deserializeOpErrorRestoreDBClusterFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6623 var errorBuffer bytes.Buffer 6624 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6625 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6626 } 6627 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6628 6629 errorCode := "UnknownError" 6630 errorMessage := errorCode 6631 6632 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6633 if err != nil { 6634 return err 6635 } 6636 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6637 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6638 } 6639 if len(errorComponents.Code) != 0 { 6640 errorCode = errorComponents.Code 6641 } 6642 if len(errorComponents.Message) != 0 { 6643 errorMessage = errorComponents.Message 6644 } 6645 errorBody.Seek(0, io.SeekStart) 6646 switch { 6647 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 6648 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 6649 6650 case strings.EqualFold("DBClusterParameterGroupNotFound", errorCode): 6651 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 6652 6653 case strings.EqualFold("DBClusterQuotaExceededFault", errorCode): 6654 return awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response, errorBody) 6655 6656 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 6657 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 6658 6659 case strings.EqualFold("DBSnapshotNotFound", errorCode): 6660 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 6661 6662 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 6663 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 6664 6665 case strings.EqualFold("InsufficientDBClusterCapacityFault", errorCode): 6666 return awsAwsquery_deserializeErrorInsufficientDBClusterCapacityFault(response, errorBody) 6667 6668 case strings.EqualFold("InsufficientStorageClusterCapacity", errorCode): 6669 return awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response, errorBody) 6670 6671 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 6672 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 6673 6674 case strings.EqualFold("InvalidDBSnapshotState", errorCode): 6675 return awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response, errorBody) 6676 6677 case strings.EqualFold("InvalidRestoreFault", errorCode): 6678 return awsAwsquery_deserializeErrorInvalidRestoreFault(response, errorBody) 6679 6680 case strings.EqualFold("InvalidSubnet", errorCode): 6681 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 6682 6683 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 6684 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 6685 6686 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 6687 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 6688 6689 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 6690 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 6691 6692 case strings.EqualFold("StorageQuotaExceeded", errorCode): 6693 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 6694 6695 default: 6696 genericError := &smithy.GenericAPIError{ 6697 Code: errorCode, 6698 Message: errorMessage, 6699 } 6700 return genericError 6701 6702 } 6703} 6704 6705type awsAwsquery_deserializeOpRestoreDBClusterToPointInTime struct { 6706} 6707 6708func (*awsAwsquery_deserializeOpRestoreDBClusterToPointInTime) ID() string { 6709 return "OperationDeserializer" 6710} 6711 6712func (m *awsAwsquery_deserializeOpRestoreDBClusterToPointInTime) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6713 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6714) { 6715 out, metadata, err = next.HandleDeserialize(ctx, in) 6716 if err != nil { 6717 return out, metadata, err 6718 } 6719 6720 response, ok := out.RawResponse.(*smithyhttp.Response) 6721 if !ok { 6722 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6723 } 6724 6725 if response.StatusCode < 200 || response.StatusCode >= 300 { 6726 return out, metadata, awsAwsquery_deserializeOpErrorRestoreDBClusterToPointInTime(response, &metadata) 6727 } 6728 output := &RestoreDBClusterToPointInTimeOutput{} 6729 out.Result = output 6730 6731 var buff [1024]byte 6732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6733 body := io.TeeReader(response.Body, ringBuffer) 6734 rootDecoder := xml.NewDecoder(body) 6735 t, err := smithyxml.FetchRootElement(rootDecoder) 6736 if err == io.EOF { 6737 return out, metadata, nil 6738 } 6739 if err != nil { 6740 var snapshot bytes.Buffer 6741 io.Copy(&snapshot, ringBuffer) 6742 return out, metadata, &smithy.DeserializationError{ 6743 Err: fmt.Errorf("failed to decode response body, %w", err), 6744 Snapshot: snapshot.Bytes(), 6745 } 6746 } 6747 6748 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6749 t, err = decoder.GetElement("RestoreDBClusterToPointInTimeResult") 6750 if err != nil { 6751 var snapshot bytes.Buffer 6752 io.Copy(&snapshot, ringBuffer) 6753 err = &smithy.DeserializationError{ 6754 Err: fmt.Errorf("failed to decode response body, %w", err), 6755 Snapshot: snapshot.Bytes(), 6756 } 6757 return out, metadata, err 6758 } 6759 6760 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6761 err = awsAwsquery_deserializeOpDocumentRestoreDBClusterToPointInTimeOutput(&output, decoder) 6762 if err != nil { 6763 var snapshot bytes.Buffer 6764 io.Copy(&snapshot, ringBuffer) 6765 err = &smithy.DeserializationError{ 6766 Err: fmt.Errorf("failed to decode response body, %w", err), 6767 Snapshot: snapshot.Bytes(), 6768 } 6769 return out, metadata, err 6770 } 6771 6772 return out, metadata, err 6773} 6774 6775func awsAwsquery_deserializeOpErrorRestoreDBClusterToPointInTime(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6776 var errorBuffer bytes.Buffer 6777 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6778 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6779 } 6780 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6781 6782 errorCode := "UnknownError" 6783 errorMessage := errorCode 6784 6785 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6786 if err != nil { 6787 return err 6788 } 6789 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6790 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6791 } 6792 if len(errorComponents.Code) != 0 { 6793 errorCode = errorComponents.Code 6794 } 6795 if len(errorComponents.Message) != 0 { 6796 errorMessage = errorComponents.Message 6797 } 6798 errorBody.Seek(0, io.SeekStart) 6799 switch { 6800 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 6801 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 6802 6803 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6804 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6805 6806 case strings.EqualFold("DBClusterParameterGroupNotFound", errorCode): 6807 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 6808 6809 case strings.EqualFold("DBClusterQuotaExceededFault", errorCode): 6810 return awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response, errorBody) 6811 6812 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 6813 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 6814 6815 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 6816 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 6817 6818 case strings.EqualFold("InsufficientDBClusterCapacityFault", errorCode): 6819 return awsAwsquery_deserializeErrorInsufficientDBClusterCapacityFault(response, errorBody) 6820 6821 case strings.EqualFold("InsufficientStorageClusterCapacity", errorCode): 6822 return awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response, errorBody) 6823 6824 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 6825 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 6826 6827 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 6828 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 6829 6830 case strings.EqualFold("InvalidDBSnapshotState", errorCode): 6831 return awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response, errorBody) 6832 6833 case strings.EqualFold("InvalidRestoreFault", errorCode): 6834 return awsAwsquery_deserializeErrorInvalidRestoreFault(response, errorBody) 6835 6836 case strings.EqualFold("InvalidSubnet", errorCode): 6837 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 6838 6839 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 6840 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 6841 6842 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 6843 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 6844 6845 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 6846 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 6847 6848 case strings.EqualFold("StorageQuotaExceeded", errorCode): 6849 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 6850 6851 default: 6852 genericError := &smithy.GenericAPIError{ 6853 Code: errorCode, 6854 Message: errorMessage, 6855 } 6856 return genericError 6857 6858 } 6859} 6860 6861type awsAwsquery_deserializeOpStartDBCluster struct { 6862} 6863 6864func (*awsAwsquery_deserializeOpStartDBCluster) ID() string { 6865 return "OperationDeserializer" 6866} 6867 6868func (m *awsAwsquery_deserializeOpStartDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6869 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6870) { 6871 out, metadata, err = next.HandleDeserialize(ctx, in) 6872 if err != nil { 6873 return out, metadata, err 6874 } 6875 6876 response, ok := out.RawResponse.(*smithyhttp.Response) 6877 if !ok { 6878 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6879 } 6880 6881 if response.StatusCode < 200 || response.StatusCode >= 300 { 6882 return out, metadata, awsAwsquery_deserializeOpErrorStartDBCluster(response, &metadata) 6883 } 6884 output := &StartDBClusterOutput{} 6885 out.Result = output 6886 6887 var buff [1024]byte 6888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6889 body := io.TeeReader(response.Body, ringBuffer) 6890 rootDecoder := xml.NewDecoder(body) 6891 t, err := smithyxml.FetchRootElement(rootDecoder) 6892 if err == io.EOF { 6893 return out, metadata, nil 6894 } 6895 if err != nil { 6896 var snapshot bytes.Buffer 6897 io.Copy(&snapshot, ringBuffer) 6898 return out, metadata, &smithy.DeserializationError{ 6899 Err: fmt.Errorf("failed to decode response body, %w", err), 6900 Snapshot: snapshot.Bytes(), 6901 } 6902 } 6903 6904 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6905 t, err = decoder.GetElement("StartDBClusterResult") 6906 if err != nil { 6907 var snapshot bytes.Buffer 6908 io.Copy(&snapshot, ringBuffer) 6909 err = &smithy.DeserializationError{ 6910 Err: fmt.Errorf("failed to decode response body, %w", err), 6911 Snapshot: snapshot.Bytes(), 6912 } 6913 return out, metadata, err 6914 } 6915 6916 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6917 err = awsAwsquery_deserializeOpDocumentStartDBClusterOutput(&output, decoder) 6918 if err != nil { 6919 var snapshot bytes.Buffer 6920 io.Copy(&snapshot, ringBuffer) 6921 err = &smithy.DeserializationError{ 6922 Err: fmt.Errorf("failed to decode response body, %w", err), 6923 Snapshot: snapshot.Bytes(), 6924 } 6925 return out, metadata, err 6926 } 6927 6928 return out, metadata, err 6929} 6930 6931func awsAwsquery_deserializeOpErrorStartDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6932 var errorBuffer bytes.Buffer 6933 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6934 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6935 } 6936 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6937 6938 errorCode := "UnknownError" 6939 errorMessage := errorCode 6940 6941 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6942 if err != nil { 6943 return err 6944 } 6945 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6946 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6947 } 6948 if len(errorComponents.Code) != 0 { 6949 errorCode = errorComponents.Code 6950 } 6951 if len(errorComponents.Message) != 0 { 6952 errorMessage = errorComponents.Message 6953 } 6954 errorBody.Seek(0, io.SeekStart) 6955 switch { 6956 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6957 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6958 6959 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 6960 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 6961 6962 case strings.EqualFold("InvalidDBInstanceState", errorCode): 6963 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 6964 6965 default: 6966 genericError := &smithy.GenericAPIError{ 6967 Code: errorCode, 6968 Message: errorMessage, 6969 } 6970 return genericError 6971 6972 } 6973} 6974 6975type awsAwsquery_deserializeOpStopDBCluster struct { 6976} 6977 6978func (*awsAwsquery_deserializeOpStopDBCluster) ID() string { 6979 return "OperationDeserializer" 6980} 6981 6982func (m *awsAwsquery_deserializeOpStopDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6983 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6984) { 6985 out, metadata, err = next.HandleDeserialize(ctx, in) 6986 if err != nil { 6987 return out, metadata, err 6988 } 6989 6990 response, ok := out.RawResponse.(*smithyhttp.Response) 6991 if !ok { 6992 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6993 } 6994 6995 if response.StatusCode < 200 || response.StatusCode >= 300 { 6996 return out, metadata, awsAwsquery_deserializeOpErrorStopDBCluster(response, &metadata) 6997 } 6998 output := &StopDBClusterOutput{} 6999 out.Result = output 7000 7001 var buff [1024]byte 7002 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7003 body := io.TeeReader(response.Body, ringBuffer) 7004 rootDecoder := xml.NewDecoder(body) 7005 t, err := smithyxml.FetchRootElement(rootDecoder) 7006 if err == io.EOF { 7007 return out, metadata, nil 7008 } 7009 if err != nil { 7010 var snapshot bytes.Buffer 7011 io.Copy(&snapshot, ringBuffer) 7012 return out, metadata, &smithy.DeserializationError{ 7013 Err: fmt.Errorf("failed to decode response body, %w", err), 7014 Snapshot: snapshot.Bytes(), 7015 } 7016 } 7017 7018 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7019 t, err = decoder.GetElement("StopDBClusterResult") 7020 if err != nil { 7021 var snapshot bytes.Buffer 7022 io.Copy(&snapshot, ringBuffer) 7023 err = &smithy.DeserializationError{ 7024 Err: fmt.Errorf("failed to decode response body, %w", err), 7025 Snapshot: snapshot.Bytes(), 7026 } 7027 return out, metadata, err 7028 } 7029 7030 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7031 err = awsAwsquery_deserializeOpDocumentStopDBClusterOutput(&output, decoder) 7032 if err != nil { 7033 var snapshot bytes.Buffer 7034 io.Copy(&snapshot, ringBuffer) 7035 err = &smithy.DeserializationError{ 7036 Err: fmt.Errorf("failed to decode response body, %w", err), 7037 Snapshot: snapshot.Bytes(), 7038 } 7039 return out, metadata, err 7040 } 7041 7042 return out, metadata, err 7043} 7044 7045func awsAwsquery_deserializeOpErrorStopDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7046 var errorBuffer bytes.Buffer 7047 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7048 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7049 } 7050 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7051 7052 errorCode := "UnknownError" 7053 errorMessage := errorCode 7054 7055 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7056 if err != nil { 7057 return err 7058 } 7059 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7060 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7061 } 7062 if len(errorComponents.Code) != 0 { 7063 errorCode = errorComponents.Code 7064 } 7065 if len(errorComponents.Message) != 0 { 7066 errorMessage = errorComponents.Message 7067 } 7068 errorBody.Seek(0, io.SeekStart) 7069 switch { 7070 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 7071 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 7072 7073 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 7074 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 7075 7076 case strings.EqualFold("InvalidDBInstanceState", errorCode): 7077 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 7078 7079 default: 7080 genericError := &smithy.GenericAPIError{ 7081 Code: errorCode, 7082 Message: errorMessage, 7083 } 7084 return genericError 7085 7086 } 7087} 7088 7089func awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7090 output := &types.AuthorizationNotFoundFault{} 7091 var buff [1024]byte 7092 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7093 body := io.TeeReader(errorBody, ringBuffer) 7094 rootDecoder := xml.NewDecoder(body) 7095 t, err := smithyxml.FetchRootElement(rootDecoder) 7096 if err == io.EOF { 7097 return output 7098 } 7099 if err != nil { 7100 var snapshot bytes.Buffer 7101 io.Copy(&snapshot, ringBuffer) 7102 return &smithy.DeserializationError{ 7103 Err: fmt.Errorf("failed to decode response body, %w", err), 7104 Snapshot: snapshot.Bytes(), 7105 } 7106 } 7107 7108 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7109 t, err = decoder.GetElement("Error") 7110 if err != nil { 7111 var snapshot bytes.Buffer 7112 io.Copy(&snapshot, ringBuffer) 7113 return &smithy.DeserializationError{ 7114 Err: fmt.Errorf("failed to decode response body, %w", err), 7115 Snapshot: snapshot.Bytes(), 7116 } 7117 } 7118 7119 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7120 err = awsAwsquery_deserializeDocumentAuthorizationNotFoundFault(&output, decoder) 7121 if err != nil { 7122 var snapshot bytes.Buffer 7123 io.Copy(&snapshot, ringBuffer) 7124 return &smithy.DeserializationError{ 7125 Err: fmt.Errorf("failed to decode response body, %w", err), 7126 Snapshot: snapshot.Bytes(), 7127 } 7128 } 7129 7130 return output 7131} 7132 7133func awsAwsquery_deserializeErrorCertificateNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7134 output := &types.CertificateNotFoundFault{} 7135 var buff [1024]byte 7136 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7137 body := io.TeeReader(errorBody, ringBuffer) 7138 rootDecoder := xml.NewDecoder(body) 7139 t, err := smithyxml.FetchRootElement(rootDecoder) 7140 if err == io.EOF { 7141 return output 7142 } 7143 if err != nil { 7144 var snapshot bytes.Buffer 7145 io.Copy(&snapshot, ringBuffer) 7146 return &smithy.DeserializationError{ 7147 Err: fmt.Errorf("failed to decode response body, %w", err), 7148 Snapshot: snapshot.Bytes(), 7149 } 7150 } 7151 7152 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7153 t, err = decoder.GetElement("Error") 7154 if err != nil { 7155 var snapshot bytes.Buffer 7156 io.Copy(&snapshot, ringBuffer) 7157 return &smithy.DeserializationError{ 7158 Err: fmt.Errorf("failed to decode response body, %w", err), 7159 Snapshot: snapshot.Bytes(), 7160 } 7161 } 7162 7163 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7164 err = awsAwsquery_deserializeDocumentCertificateNotFoundFault(&output, decoder) 7165 if err != nil { 7166 var snapshot bytes.Buffer 7167 io.Copy(&snapshot, ringBuffer) 7168 return &smithy.DeserializationError{ 7169 Err: fmt.Errorf("failed to decode response body, %w", err), 7170 Snapshot: snapshot.Bytes(), 7171 } 7172 } 7173 7174 return output 7175} 7176 7177func awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7178 output := &types.DBClusterAlreadyExistsFault{} 7179 var buff [1024]byte 7180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7181 body := io.TeeReader(errorBody, ringBuffer) 7182 rootDecoder := xml.NewDecoder(body) 7183 t, err := smithyxml.FetchRootElement(rootDecoder) 7184 if err == io.EOF { 7185 return output 7186 } 7187 if err != nil { 7188 var snapshot bytes.Buffer 7189 io.Copy(&snapshot, ringBuffer) 7190 return &smithy.DeserializationError{ 7191 Err: fmt.Errorf("failed to decode response body, %w", err), 7192 Snapshot: snapshot.Bytes(), 7193 } 7194 } 7195 7196 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7197 t, err = decoder.GetElement("Error") 7198 if err != nil { 7199 var snapshot bytes.Buffer 7200 io.Copy(&snapshot, ringBuffer) 7201 return &smithy.DeserializationError{ 7202 Err: fmt.Errorf("failed to decode response body, %w", err), 7203 Snapshot: snapshot.Bytes(), 7204 } 7205 } 7206 7207 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7208 err = awsAwsquery_deserializeDocumentDBClusterAlreadyExistsFault(&output, decoder) 7209 if err != nil { 7210 var snapshot bytes.Buffer 7211 io.Copy(&snapshot, ringBuffer) 7212 return &smithy.DeserializationError{ 7213 Err: fmt.Errorf("failed to decode response body, %w", err), 7214 Snapshot: snapshot.Bytes(), 7215 } 7216 } 7217 7218 return output 7219} 7220 7221func awsAwsquery_deserializeErrorDBClusterEndpointAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7222 output := &types.DBClusterEndpointAlreadyExistsFault{} 7223 var buff [1024]byte 7224 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7225 body := io.TeeReader(errorBody, ringBuffer) 7226 rootDecoder := xml.NewDecoder(body) 7227 t, err := smithyxml.FetchRootElement(rootDecoder) 7228 if err == io.EOF { 7229 return output 7230 } 7231 if err != nil { 7232 var snapshot bytes.Buffer 7233 io.Copy(&snapshot, ringBuffer) 7234 return &smithy.DeserializationError{ 7235 Err: fmt.Errorf("failed to decode response body, %w", err), 7236 Snapshot: snapshot.Bytes(), 7237 } 7238 } 7239 7240 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7241 t, err = decoder.GetElement("Error") 7242 if err != nil { 7243 var snapshot bytes.Buffer 7244 io.Copy(&snapshot, ringBuffer) 7245 return &smithy.DeserializationError{ 7246 Err: fmt.Errorf("failed to decode response body, %w", err), 7247 Snapshot: snapshot.Bytes(), 7248 } 7249 } 7250 7251 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7252 err = awsAwsquery_deserializeDocumentDBClusterEndpointAlreadyExistsFault(&output, decoder) 7253 if err != nil { 7254 var snapshot bytes.Buffer 7255 io.Copy(&snapshot, ringBuffer) 7256 return &smithy.DeserializationError{ 7257 Err: fmt.Errorf("failed to decode response body, %w", err), 7258 Snapshot: snapshot.Bytes(), 7259 } 7260 } 7261 7262 return output 7263} 7264 7265func awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7266 output := &types.DBClusterEndpointNotFoundFault{} 7267 var buff [1024]byte 7268 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7269 body := io.TeeReader(errorBody, ringBuffer) 7270 rootDecoder := xml.NewDecoder(body) 7271 t, err := smithyxml.FetchRootElement(rootDecoder) 7272 if err == io.EOF { 7273 return output 7274 } 7275 if err != nil { 7276 var snapshot bytes.Buffer 7277 io.Copy(&snapshot, ringBuffer) 7278 return &smithy.DeserializationError{ 7279 Err: fmt.Errorf("failed to decode response body, %w", err), 7280 Snapshot: snapshot.Bytes(), 7281 } 7282 } 7283 7284 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7285 t, err = decoder.GetElement("Error") 7286 if err != nil { 7287 var snapshot bytes.Buffer 7288 io.Copy(&snapshot, ringBuffer) 7289 return &smithy.DeserializationError{ 7290 Err: fmt.Errorf("failed to decode response body, %w", err), 7291 Snapshot: snapshot.Bytes(), 7292 } 7293 } 7294 7295 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7296 err = awsAwsquery_deserializeDocumentDBClusterEndpointNotFoundFault(&output, decoder) 7297 if err != nil { 7298 var snapshot bytes.Buffer 7299 io.Copy(&snapshot, ringBuffer) 7300 return &smithy.DeserializationError{ 7301 Err: fmt.Errorf("failed to decode response body, %w", err), 7302 Snapshot: snapshot.Bytes(), 7303 } 7304 } 7305 7306 return output 7307} 7308 7309func awsAwsquery_deserializeErrorDBClusterEndpointQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7310 output := &types.DBClusterEndpointQuotaExceededFault{} 7311 var buff [1024]byte 7312 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7313 body := io.TeeReader(errorBody, ringBuffer) 7314 rootDecoder := xml.NewDecoder(body) 7315 t, err := smithyxml.FetchRootElement(rootDecoder) 7316 if err == io.EOF { 7317 return output 7318 } 7319 if err != nil { 7320 var snapshot bytes.Buffer 7321 io.Copy(&snapshot, ringBuffer) 7322 return &smithy.DeserializationError{ 7323 Err: fmt.Errorf("failed to decode response body, %w", err), 7324 Snapshot: snapshot.Bytes(), 7325 } 7326 } 7327 7328 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7329 t, err = decoder.GetElement("Error") 7330 if err != nil { 7331 var snapshot bytes.Buffer 7332 io.Copy(&snapshot, ringBuffer) 7333 return &smithy.DeserializationError{ 7334 Err: fmt.Errorf("failed to decode response body, %w", err), 7335 Snapshot: snapshot.Bytes(), 7336 } 7337 } 7338 7339 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7340 err = awsAwsquery_deserializeDocumentDBClusterEndpointQuotaExceededFault(&output, decoder) 7341 if err != nil { 7342 var snapshot bytes.Buffer 7343 io.Copy(&snapshot, ringBuffer) 7344 return &smithy.DeserializationError{ 7345 Err: fmt.Errorf("failed to decode response body, %w", err), 7346 Snapshot: snapshot.Bytes(), 7347 } 7348 } 7349 7350 return output 7351} 7352 7353func awsAwsquery_deserializeErrorDBClusterNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7354 output := &types.DBClusterNotFoundFault{} 7355 var buff [1024]byte 7356 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7357 body := io.TeeReader(errorBody, ringBuffer) 7358 rootDecoder := xml.NewDecoder(body) 7359 t, err := smithyxml.FetchRootElement(rootDecoder) 7360 if err == io.EOF { 7361 return output 7362 } 7363 if err != nil { 7364 var snapshot bytes.Buffer 7365 io.Copy(&snapshot, ringBuffer) 7366 return &smithy.DeserializationError{ 7367 Err: fmt.Errorf("failed to decode response body, %w", err), 7368 Snapshot: snapshot.Bytes(), 7369 } 7370 } 7371 7372 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7373 t, err = decoder.GetElement("Error") 7374 if err != nil { 7375 var snapshot bytes.Buffer 7376 io.Copy(&snapshot, ringBuffer) 7377 return &smithy.DeserializationError{ 7378 Err: fmt.Errorf("failed to decode response body, %w", err), 7379 Snapshot: snapshot.Bytes(), 7380 } 7381 } 7382 7383 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7384 err = awsAwsquery_deserializeDocumentDBClusterNotFoundFault(&output, decoder) 7385 if err != nil { 7386 var snapshot bytes.Buffer 7387 io.Copy(&snapshot, ringBuffer) 7388 return &smithy.DeserializationError{ 7389 Err: fmt.Errorf("failed to decode response body, %w", err), 7390 Snapshot: snapshot.Bytes(), 7391 } 7392 } 7393 7394 return output 7395} 7396 7397func awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7398 output := &types.DBClusterParameterGroupNotFoundFault{} 7399 var buff [1024]byte 7400 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7401 body := io.TeeReader(errorBody, ringBuffer) 7402 rootDecoder := xml.NewDecoder(body) 7403 t, err := smithyxml.FetchRootElement(rootDecoder) 7404 if err == io.EOF { 7405 return output 7406 } 7407 if err != nil { 7408 var snapshot bytes.Buffer 7409 io.Copy(&snapshot, ringBuffer) 7410 return &smithy.DeserializationError{ 7411 Err: fmt.Errorf("failed to decode response body, %w", err), 7412 Snapshot: snapshot.Bytes(), 7413 } 7414 } 7415 7416 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7417 t, err = decoder.GetElement("Error") 7418 if err != nil { 7419 var snapshot bytes.Buffer 7420 io.Copy(&snapshot, ringBuffer) 7421 return &smithy.DeserializationError{ 7422 Err: fmt.Errorf("failed to decode response body, %w", err), 7423 Snapshot: snapshot.Bytes(), 7424 } 7425 } 7426 7427 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7428 err = awsAwsquery_deserializeDocumentDBClusterParameterGroupNotFoundFault(&output, decoder) 7429 if err != nil { 7430 var snapshot bytes.Buffer 7431 io.Copy(&snapshot, ringBuffer) 7432 return &smithy.DeserializationError{ 7433 Err: fmt.Errorf("failed to decode response body, %w", err), 7434 Snapshot: snapshot.Bytes(), 7435 } 7436 } 7437 7438 return output 7439} 7440 7441func awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7442 output := &types.DBClusterQuotaExceededFault{} 7443 var buff [1024]byte 7444 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7445 body := io.TeeReader(errorBody, ringBuffer) 7446 rootDecoder := xml.NewDecoder(body) 7447 t, err := smithyxml.FetchRootElement(rootDecoder) 7448 if err == io.EOF { 7449 return output 7450 } 7451 if err != nil { 7452 var snapshot bytes.Buffer 7453 io.Copy(&snapshot, ringBuffer) 7454 return &smithy.DeserializationError{ 7455 Err: fmt.Errorf("failed to decode response body, %w", err), 7456 Snapshot: snapshot.Bytes(), 7457 } 7458 } 7459 7460 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7461 t, err = decoder.GetElement("Error") 7462 if err != nil { 7463 var snapshot bytes.Buffer 7464 io.Copy(&snapshot, ringBuffer) 7465 return &smithy.DeserializationError{ 7466 Err: fmt.Errorf("failed to decode response body, %w", err), 7467 Snapshot: snapshot.Bytes(), 7468 } 7469 } 7470 7471 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7472 err = awsAwsquery_deserializeDocumentDBClusterQuotaExceededFault(&output, decoder) 7473 if err != nil { 7474 var snapshot bytes.Buffer 7475 io.Copy(&snapshot, ringBuffer) 7476 return &smithy.DeserializationError{ 7477 Err: fmt.Errorf("failed to decode response body, %w", err), 7478 Snapshot: snapshot.Bytes(), 7479 } 7480 } 7481 7482 return output 7483} 7484 7485func awsAwsquery_deserializeErrorDBClusterRoleAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7486 output := &types.DBClusterRoleAlreadyExistsFault{} 7487 var buff [1024]byte 7488 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7489 body := io.TeeReader(errorBody, ringBuffer) 7490 rootDecoder := xml.NewDecoder(body) 7491 t, err := smithyxml.FetchRootElement(rootDecoder) 7492 if err == io.EOF { 7493 return output 7494 } 7495 if err != nil { 7496 var snapshot bytes.Buffer 7497 io.Copy(&snapshot, ringBuffer) 7498 return &smithy.DeserializationError{ 7499 Err: fmt.Errorf("failed to decode response body, %w", err), 7500 Snapshot: snapshot.Bytes(), 7501 } 7502 } 7503 7504 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7505 t, err = decoder.GetElement("Error") 7506 if err != nil { 7507 var snapshot bytes.Buffer 7508 io.Copy(&snapshot, ringBuffer) 7509 return &smithy.DeserializationError{ 7510 Err: fmt.Errorf("failed to decode response body, %w", err), 7511 Snapshot: snapshot.Bytes(), 7512 } 7513 } 7514 7515 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7516 err = awsAwsquery_deserializeDocumentDBClusterRoleAlreadyExistsFault(&output, decoder) 7517 if err != nil { 7518 var snapshot bytes.Buffer 7519 io.Copy(&snapshot, ringBuffer) 7520 return &smithy.DeserializationError{ 7521 Err: fmt.Errorf("failed to decode response body, %w", err), 7522 Snapshot: snapshot.Bytes(), 7523 } 7524 } 7525 7526 return output 7527} 7528 7529func awsAwsquery_deserializeErrorDBClusterRoleNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7530 output := &types.DBClusterRoleNotFoundFault{} 7531 var buff [1024]byte 7532 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7533 body := io.TeeReader(errorBody, ringBuffer) 7534 rootDecoder := xml.NewDecoder(body) 7535 t, err := smithyxml.FetchRootElement(rootDecoder) 7536 if err == io.EOF { 7537 return output 7538 } 7539 if err != nil { 7540 var snapshot bytes.Buffer 7541 io.Copy(&snapshot, ringBuffer) 7542 return &smithy.DeserializationError{ 7543 Err: fmt.Errorf("failed to decode response body, %w", err), 7544 Snapshot: snapshot.Bytes(), 7545 } 7546 } 7547 7548 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7549 t, err = decoder.GetElement("Error") 7550 if err != nil { 7551 var snapshot bytes.Buffer 7552 io.Copy(&snapshot, ringBuffer) 7553 return &smithy.DeserializationError{ 7554 Err: fmt.Errorf("failed to decode response body, %w", err), 7555 Snapshot: snapshot.Bytes(), 7556 } 7557 } 7558 7559 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7560 err = awsAwsquery_deserializeDocumentDBClusterRoleNotFoundFault(&output, decoder) 7561 if err != nil { 7562 var snapshot bytes.Buffer 7563 io.Copy(&snapshot, ringBuffer) 7564 return &smithy.DeserializationError{ 7565 Err: fmt.Errorf("failed to decode response body, %w", err), 7566 Snapshot: snapshot.Bytes(), 7567 } 7568 } 7569 7570 return output 7571} 7572 7573func awsAwsquery_deserializeErrorDBClusterRoleQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7574 output := &types.DBClusterRoleQuotaExceededFault{} 7575 var buff [1024]byte 7576 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7577 body := io.TeeReader(errorBody, ringBuffer) 7578 rootDecoder := xml.NewDecoder(body) 7579 t, err := smithyxml.FetchRootElement(rootDecoder) 7580 if err == io.EOF { 7581 return output 7582 } 7583 if err != nil { 7584 var snapshot bytes.Buffer 7585 io.Copy(&snapshot, ringBuffer) 7586 return &smithy.DeserializationError{ 7587 Err: fmt.Errorf("failed to decode response body, %w", err), 7588 Snapshot: snapshot.Bytes(), 7589 } 7590 } 7591 7592 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7593 t, err = decoder.GetElement("Error") 7594 if err != nil { 7595 var snapshot bytes.Buffer 7596 io.Copy(&snapshot, ringBuffer) 7597 return &smithy.DeserializationError{ 7598 Err: fmt.Errorf("failed to decode response body, %w", err), 7599 Snapshot: snapshot.Bytes(), 7600 } 7601 } 7602 7603 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7604 err = awsAwsquery_deserializeDocumentDBClusterRoleQuotaExceededFault(&output, decoder) 7605 if err != nil { 7606 var snapshot bytes.Buffer 7607 io.Copy(&snapshot, ringBuffer) 7608 return &smithy.DeserializationError{ 7609 Err: fmt.Errorf("failed to decode response body, %w", err), 7610 Snapshot: snapshot.Bytes(), 7611 } 7612 } 7613 7614 return output 7615} 7616 7617func awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7618 output := &types.DBClusterSnapshotAlreadyExistsFault{} 7619 var buff [1024]byte 7620 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7621 body := io.TeeReader(errorBody, ringBuffer) 7622 rootDecoder := xml.NewDecoder(body) 7623 t, err := smithyxml.FetchRootElement(rootDecoder) 7624 if err == io.EOF { 7625 return output 7626 } 7627 if err != nil { 7628 var snapshot bytes.Buffer 7629 io.Copy(&snapshot, ringBuffer) 7630 return &smithy.DeserializationError{ 7631 Err: fmt.Errorf("failed to decode response body, %w", err), 7632 Snapshot: snapshot.Bytes(), 7633 } 7634 } 7635 7636 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7637 t, err = decoder.GetElement("Error") 7638 if err != nil { 7639 var snapshot bytes.Buffer 7640 io.Copy(&snapshot, ringBuffer) 7641 return &smithy.DeserializationError{ 7642 Err: fmt.Errorf("failed to decode response body, %w", err), 7643 Snapshot: snapshot.Bytes(), 7644 } 7645 } 7646 7647 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7648 err = awsAwsquery_deserializeDocumentDBClusterSnapshotAlreadyExistsFault(&output, decoder) 7649 if err != nil { 7650 var snapshot bytes.Buffer 7651 io.Copy(&snapshot, ringBuffer) 7652 return &smithy.DeserializationError{ 7653 Err: fmt.Errorf("failed to decode response body, %w", err), 7654 Snapshot: snapshot.Bytes(), 7655 } 7656 } 7657 7658 return output 7659} 7660 7661func awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7662 output := &types.DBClusterSnapshotNotFoundFault{} 7663 var buff [1024]byte 7664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7665 body := io.TeeReader(errorBody, ringBuffer) 7666 rootDecoder := xml.NewDecoder(body) 7667 t, err := smithyxml.FetchRootElement(rootDecoder) 7668 if err == io.EOF { 7669 return output 7670 } 7671 if err != nil { 7672 var snapshot bytes.Buffer 7673 io.Copy(&snapshot, ringBuffer) 7674 return &smithy.DeserializationError{ 7675 Err: fmt.Errorf("failed to decode response body, %w", err), 7676 Snapshot: snapshot.Bytes(), 7677 } 7678 } 7679 7680 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7681 t, err = decoder.GetElement("Error") 7682 if err != nil { 7683 var snapshot bytes.Buffer 7684 io.Copy(&snapshot, ringBuffer) 7685 return &smithy.DeserializationError{ 7686 Err: fmt.Errorf("failed to decode response body, %w", err), 7687 Snapshot: snapshot.Bytes(), 7688 } 7689 } 7690 7691 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7692 err = awsAwsquery_deserializeDocumentDBClusterSnapshotNotFoundFault(&output, decoder) 7693 if err != nil { 7694 var snapshot bytes.Buffer 7695 io.Copy(&snapshot, ringBuffer) 7696 return &smithy.DeserializationError{ 7697 Err: fmt.Errorf("failed to decode response body, %w", err), 7698 Snapshot: snapshot.Bytes(), 7699 } 7700 } 7701 7702 return output 7703} 7704 7705func awsAwsquery_deserializeErrorDBInstanceAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7706 output := &types.DBInstanceAlreadyExistsFault{} 7707 var buff [1024]byte 7708 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7709 body := io.TeeReader(errorBody, ringBuffer) 7710 rootDecoder := xml.NewDecoder(body) 7711 t, err := smithyxml.FetchRootElement(rootDecoder) 7712 if err == io.EOF { 7713 return output 7714 } 7715 if err != nil { 7716 var snapshot bytes.Buffer 7717 io.Copy(&snapshot, ringBuffer) 7718 return &smithy.DeserializationError{ 7719 Err: fmt.Errorf("failed to decode response body, %w", err), 7720 Snapshot: snapshot.Bytes(), 7721 } 7722 } 7723 7724 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7725 t, err = decoder.GetElement("Error") 7726 if err != nil { 7727 var snapshot bytes.Buffer 7728 io.Copy(&snapshot, ringBuffer) 7729 return &smithy.DeserializationError{ 7730 Err: fmt.Errorf("failed to decode response body, %w", err), 7731 Snapshot: snapshot.Bytes(), 7732 } 7733 } 7734 7735 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7736 err = awsAwsquery_deserializeDocumentDBInstanceAlreadyExistsFault(&output, decoder) 7737 if err != nil { 7738 var snapshot bytes.Buffer 7739 io.Copy(&snapshot, ringBuffer) 7740 return &smithy.DeserializationError{ 7741 Err: fmt.Errorf("failed to decode response body, %w", err), 7742 Snapshot: snapshot.Bytes(), 7743 } 7744 } 7745 7746 return output 7747} 7748 7749func awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7750 output := &types.DBInstanceNotFoundFault{} 7751 var buff [1024]byte 7752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7753 body := io.TeeReader(errorBody, ringBuffer) 7754 rootDecoder := xml.NewDecoder(body) 7755 t, err := smithyxml.FetchRootElement(rootDecoder) 7756 if err == io.EOF { 7757 return output 7758 } 7759 if err != nil { 7760 var snapshot bytes.Buffer 7761 io.Copy(&snapshot, ringBuffer) 7762 return &smithy.DeserializationError{ 7763 Err: fmt.Errorf("failed to decode response body, %w", err), 7764 Snapshot: snapshot.Bytes(), 7765 } 7766 } 7767 7768 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7769 t, err = decoder.GetElement("Error") 7770 if err != nil { 7771 var snapshot bytes.Buffer 7772 io.Copy(&snapshot, ringBuffer) 7773 return &smithy.DeserializationError{ 7774 Err: fmt.Errorf("failed to decode response body, %w", err), 7775 Snapshot: snapshot.Bytes(), 7776 } 7777 } 7778 7779 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7780 err = awsAwsquery_deserializeDocumentDBInstanceNotFoundFault(&output, decoder) 7781 if err != nil { 7782 var snapshot bytes.Buffer 7783 io.Copy(&snapshot, ringBuffer) 7784 return &smithy.DeserializationError{ 7785 Err: fmt.Errorf("failed to decode response body, %w", err), 7786 Snapshot: snapshot.Bytes(), 7787 } 7788 } 7789 7790 return output 7791} 7792 7793func awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7794 output := &types.DBParameterGroupAlreadyExistsFault{} 7795 var buff [1024]byte 7796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7797 body := io.TeeReader(errorBody, ringBuffer) 7798 rootDecoder := xml.NewDecoder(body) 7799 t, err := smithyxml.FetchRootElement(rootDecoder) 7800 if err == io.EOF { 7801 return output 7802 } 7803 if err != nil { 7804 var snapshot bytes.Buffer 7805 io.Copy(&snapshot, ringBuffer) 7806 return &smithy.DeserializationError{ 7807 Err: fmt.Errorf("failed to decode response body, %w", err), 7808 Snapshot: snapshot.Bytes(), 7809 } 7810 } 7811 7812 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7813 t, err = decoder.GetElement("Error") 7814 if err != nil { 7815 var snapshot bytes.Buffer 7816 io.Copy(&snapshot, ringBuffer) 7817 return &smithy.DeserializationError{ 7818 Err: fmt.Errorf("failed to decode response body, %w", err), 7819 Snapshot: snapshot.Bytes(), 7820 } 7821 } 7822 7823 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7824 err = awsAwsquery_deserializeDocumentDBParameterGroupAlreadyExistsFault(&output, decoder) 7825 if err != nil { 7826 var snapshot bytes.Buffer 7827 io.Copy(&snapshot, ringBuffer) 7828 return &smithy.DeserializationError{ 7829 Err: fmt.Errorf("failed to decode response body, %w", err), 7830 Snapshot: snapshot.Bytes(), 7831 } 7832 } 7833 7834 return output 7835} 7836 7837func awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7838 output := &types.DBParameterGroupNotFoundFault{} 7839 var buff [1024]byte 7840 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7841 body := io.TeeReader(errorBody, ringBuffer) 7842 rootDecoder := xml.NewDecoder(body) 7843 t, err := smithyxml.FetchRootElement(rootDecoder) 7844 if err == io.EOF { 7845 return output 7846 } 7847 if err != nil { 7848 var snapshot bytes.Buffer 7849 io.Copy(&snapshot, ringBuffer) 7850 return &smithy.DeserializationError{ 7851 Err: fmt.Errorf("failed to decode response body, %w", err), 7852 Snapshot: snapshot.Bytes(), 7853 } 7854 } 7855 7856 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7857 t, err = decoder.GetElement("Error") 7858 if err != nil { 7859 var snapshot bytes.Buffer 7860 io.Copy(&snapshot, ringBuffer) 7861 return &smithy.DeserializationError{ 7862 Err: fmt.Errorf("failed to decode response body, %w", err), 7863 Snapshot: snapshot.Bytes(), 7864 } 7865 } 7866 7867 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7868 err = awsAwsquery_deserializeDocumentDBParameterGroupNotFoundFault(&output, decoder) 7869 if err != nil { 7870 var snapshot bytes.Buffer 7871 io.Copy(&snapshot, ringBuffer) 7872 return &smithy.DeserializationError{ 7873 Err: fmt.Errorf("failed to decode response body, %w", err), 7874 Snapshot: snapshot.Bytes(), 7875 } 7876 } 7877 7878 return output 7879} 7880 7881func awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7882 output := &types.DBParameterGroupQuotaExceededFault{} 7883 var buff [1024]byte 7884 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7885 body := io.TeeReader(errorBody, ringBuffer) 7886 rootDecoder := xml.NewDecoder(body) 7887 t, err := smithyxml.FetchRootElement(rootDecoder) 7888 if err == io.EOF { 7889 return output 7890 } 7891 if err != nil { 7892 var snapshot bytes.Buffer 7893 io.Copy(&snapshot, ringBuffer) 7894 return &smithy.DeserializationError{ 7895 Err: fmt.Errorf("failed to decode response body, %w", err), 7896 Snapshot: snapshot.Bytes(), 7897 } 7898 } 7899 7900 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7901 t, err = decoder.GetElement("Error") 7902 if err != nil { 7903 var snapshot bytes.Buffer 7904 io.Copy(&snapshot, ringBuffer) 7905 return &smithy.DeserializationError{ 7906 Err: fmt.Errorf("failed to decode response body, %w", err), 7907 Snapshot: snapshot.Bytes(), 7908 } 7909 } 7910 7911 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7912 err = awsAwsquery_deserializeDocumentDBParameterGroupQuotaExceededFault(&output, decoder) 7913 if err != nil { 7914 var snapshot bytes.Buffer 7915 io.Copy(&snapshot, ringBuffer) 7916 return &smithy.DeserializationError{ 7917 Err: fmt.Errorf("failed to decode response body, %w", err), 7918 Snapshot: snapshot.Bytes(), 7919 } 7920 } 7921 7922 return output 7923} 7924 7925func awsAwsquery_deserializeErrorDBSecurityGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7926 output := &types.DBSecurityGroupNotFoundFault{} 7927 var buff [1024]byte 7928 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7929 body := io.TeeReader(errorBody, ringBuffer) 7930 rootDecoder := xml.NewDecoder(body) 7931 t, err := smithyxml.FetchRootElement(rootDecoder) 7932 if err == io.EOF { 7933 return output 7934 } 7935 if err != nil { 7936 var snapshot bytes.Buffer 7937 io.Copy(&snapshot, ringBuffer) 7938 return &smithy.DeserializationError{ 7939 Err: fmt.Errorf("failed to decode response body, %w", err), 7940 Snapshot: snapshot.Bytes(), 7941 } 7942 } 7943 7944 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7945 t, err = decoder.GetElement("Error") 7946 if err != nil { 7947 var snapshot bytes.Buffer 7948 io.Copy(&snapshot, ringBuffer) 7949 return &smithy.DeserializationError{ 7950 Err: fmt.Errorf("failed to decode response body, %w", err), 7951 Snapshot: snapshot.Bytes(), 7952 } 7953 } 7954 7955 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7956 err = awsAwsquery_deserializeDocumentDBSecurityGroupNotFoundFault(&output, decoder) 7957 if err != nil { 7958 var snapshot bytes.Buffer 7959 io.Copy(&snapshot, ringBuffer) 7960 return &smithy.DeserializationError{ 7961 Err: fmt.Errorf("failed to decode response body, %w", err), 7962 Snapshot: snapshot.Bytes(), 7963 } 7964 } 7965 7966 return output 7967} 7968 7969func awsAwsquery_deserializeErrorDBSnapshotAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7970 output := &types.DBSnapshotAlreadyExistsFault{} 7971 var buff [1024]byte 7972 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7973 body := io.TeeReader(errorBody, ringBuffer) 7974 rootDecoder := xml.NewDecoder(body) 7975 t, err := smithyxml.FetchRootElement(rootDecoder) 7976 if err == io.EOF { 7977 return output 7978 } 7979 if err != nil { 7980 var snapshot bytes.Buffer 7981 io.Copy(&snapshot, ringBuffer) 7982 return &smithy.DeserializationError{ 7983 Err: fmt.Errorf("failed to decode response body, %w", err), 7984 Snapshot: snapshot.Bytes(), 7985 } 7986 } 7987 7988 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7989 t, err = decoder.GetElement("Error") 7990 if err != nil { 7991 var snapshot bytes.Buffer 7992 io.Copy(&snapshot, ringBuffer) 7993 return &smithy.DeserializationError{ 7994 Err: fmt.Errorf("failed to decode response body, %w", err), 7995 Snapshot: snapshot.Bytes(), 7996 } 7997 } 7998 7999 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8000 err = awsAwsquery_deserializeDocumentDBSnapshotAlreadyExistsFault(&output, decoder) 8001 if err != nil { 8002 var snapshot bytes.Buffer 8003 io.Copy(&snapshot, ringBuffer) 8004 return &smithy.DeserializationError{ 8005 Err: fmt.Errorf("failed to decode response body, %w", err), 8006 Snapshot: snapshot.Bytes(), 8007 } 8008 } 8009 8010 return output 8011} 8012 8013func awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8014 output := &types.DBSnapshotNotFoundFault{} 8015 var buff [1024]byte 8016 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8017 body := io.TeeReader(errorBody, ringBuffer) 8018 rootDecoder := xml.NewDecoder(body) 8019 t, err := smithyxml.FetchRootElement(rootDecoder) 8020 if err == io.EOF { 8021 return output 8022 } 8023 if err != nil { 8024 var snapshot bytes.Buffer 8025 io.Copy(&snapshot, ringBuffer) 8026 return &smithy.DeserializationError{ 8027 Err: fmt.Errorf("failed to decode response body, %w", err), 8028 Snapshot: snapshot.Bytes(), 8029 } 8030 } 8031 8032 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8033 t, err = decoder.GetElement("Error") 8034 if err != nil { 8035 var snapshot bytes.Buffer 8036 io.Copy(&snapshot, ringBuffer) 8037 return &smithy.DeserializationError{ 8038 Err: fmt.Errorf("failed to decode response body, %w", err), 8039 Snapshot: snapshot.Bytes(), 8040 } 8041 } 8042 8043 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8044 err = awsAwsquery_deserializeDocumentDBSnapshotNotFoundFault(&output, decoder) 8045 if err != nil { 8046 var snapshot bytes.Buffer 8047 io.Copy(&snapshot, ringBuffer) 8048 return &smithy.DeserializationError{ 8049 Err: fmt.Errorf("failed to decode response body, %w", err), 8050 Snapshot: snapshot.Bytes(), 8051 } 8052 } 8053 8054 return output 8055} 8056 8057func awsAwsquery_deserializeErrorDBSubnetGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8058 output := &types.DBSubnetGroupAlreadyExistsFault{} 8059 var buff [1024]byte 8060 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8061 body := io.TeeReader(errorBody, ringBuffer) 8062 rootDecoder := xml.NewDecoder(body) 8063 t, err := smithyxml.FetchRootElement(rootDecoder) 8064 if err == io.EOF { 8065 return output 8066 } 8067 if err != nil { 8068 var snapshot bytes.Buffer 8069 io.Copy(&snapshot, ringBuffer) 8070 return &smithy.DeserializationError{ 8071 Err: fmt.Errorf("failed to decode response body, %w", err), 8072 Snapshot: snapshot.Bytes(), 8073 } 8074 } 8075 8076 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8077 t, err = decoder.GetElement("Error") 8078 if err != nil { 8079 var snapshot bytes.Buffer 8080 io.Copy(&snapshot, ringBuffer) 8081 return &smithy.DeserializationError{ 8082 Err: fmt.Errorf("failed to decode response body, %w", err), 8083 Snapshot: snapshot.Bytes(), 8084 } 8085 } 8086 8087 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8088 err = awsAwsquery_deserializeDocumentDBSubnetGroupAlreadyExistsFault(&output, decoder) 8089 if err != nil { 8090 var snapshot bytes.Buffer 8091 io.Copy(&snapshot, ringBuffer) 8092 return &smithy.DeserializationError{ 8093 Err: fmt.Errorf("failed to decode response body, %w", err), 8094 Snapshot: snapshot.Bytes(), 8095 } 8096 } 8097 8098 return output 8099} 8100 8101func awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8102 output := &types.DBSubnetGroupDoesNotCoverEnoughAZs{} 8103 var buff [1024]byte 8104 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8105 body := io.TeeReader(errorBody, ringBuffer) 8106 rootDecoder := xml.NewDecoder(body) 8107 t, err := smithyxml.FetchRootElement(rootDecoder) 8108 if err == io.EOF { 8109 return output 8110 } 8111 if err != nil { 8112 var snapshot bytes.Buffer 8113 io.Copy(&snapshot, ringBuffer) 8114 return &smithy.DeserializationError{ 8115 Err: fmt.Errorf("failed to decode response body, %w", err), 8116 Snapshot: snapshot.Bytes(), 8117 } 8118 } 8119 8120 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8121 t, err = decoder.GetElement("Error") 8122 if err != nil { 8123 var snapshot bytes.Buffer 8124 io.Copy(&snapshot, ringBuffer) 8125 return &smithy.DeserializationError{ 8126 Err: fmt.Errorf("failed to decode response body, %w", err), 8127 Snapshot: snapshot.Bytes(), 8128 } 8129 } 8130 8131 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8132 err = awsAwsquery_deserializeDocumentDBSubnetGroupDoesNotCoverEnoughAZs(&output, decoder) 8133 if err != nil { 8134 var snapshot bytes.Buffer 8135 io.Copy(&snapshot, ringBuffer) 8136 return &smithy.DeserializationError{ 8137 Err: fmt.Errorf("failed to decode response body, %w", err), 8138 Snapshot: snapshot.Bytes(), 8139 } 8140 } 8141 8142 return output 8143} 8144 8145func awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8146 output := &types.DBSubnetGroupNotFoundFault{} 8147 var buff [1024]byte 8148 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8149 body := io.TeeReader(errorBody, ringBuffer) 8150 rootDecoder := xml.NewDecoder(body) 8151 t, err := smithyxml.FetchRootElement(rootDecoder) 8152 if err == io.EOF { 8153 return output 8154 } 8155 if err != nil { 8156 var snapshot bytes.Buffer 8157 io.Copy(&snapshot, ringBuffer) 8158 return &smithy.DeserializationError{ 8159 Err: fmt.Errorf("failed to decode response body, %w", err), 8160 Snapshot: snapshot.Bytes(), 8161 } 8162 } 8163 8164 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8165 t, err = decoder.GetElement("Error") 8166 if err != nil { 8167 var snapshot bytes.Buffer 8168 io.Copy(&snapshot, ringBuffer) 8169 return &smithy.DeserializationError{ 8170 Err: fmt.Errorf("failed to decode response body, %w", err), 8171 Snapshot: snapshot.Bytes(), 8172 } 8173 } 8174 8175 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8176 err = awsAwsquery_deserializeDocumentDBSubnetGroupNotFoundFault(&output, decoder) 8177 if err != nil { 8178 var snapshot bytes.Buffer 8179 io.Copy(&snapshot, ringBuffer) 8180 return &smithy.DeserializationError{ 8181 Err: fmt.Errorf("failed to decode response body, %w", err), 8182 Snapshot: snapshot.Bytes(), 8183 } 8184 } 8185 8186 return output 8187} 8188 8189func awsAwsquery_deserializeErrorDBSubnetGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8190 output := &types.DBSubnetGroupQuotaExceededFault{} 8191 var buff [1024]byte 8192 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8193 body := io.TeeReader(errorBody, ringBuffer) 8194 rootDecoder := xml.NewDecoder(body) 8195 t, err := smithyxml.FetchRootElement(rootDecoder) 8196 if err == io.EOF { 8197 return output 8198 } 8199 if err != nil { 8200 var snapshot bytes.Buffer 8201 io.Copy(&snapshot, ringBuffer) 8202 return &smithy.DeserializationError{ 8203 Err: fmt.Errorf("failed to decode response body, %w", err), 8204 Snapshot: snapshot.Bytes(), 8205 } 8206 } 8207 8208 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8209 t, err = decoder.GetElement("Error") 8210 if err != nil { 8211 var snapshot bytes.Buffer 8212 io.Copy(&snapshot, ringBuffer) 8213 return &smithy.DeserializationError{ 8214 Err: fmt.Errorf("failed to decode response body, %w", err), 8215 Snapshot: snapshot.Bytes(), 8216 } 8217 } 8218 8219 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8220 err = awsAwsquery_deserializeDocumentDBSubnetGroupQuotaExceededFault(&output, decoder) 8221 if err != nil { 8222 var snapshot bytes.Buffer 8223 io.Copy(&snapshot, ringBuffer) 8224 return &smithy.DeserializationError{ 8225 Err: fmt.Errorf("failed to decode response body, %w", err), 8226 Snapshot: snapshot.Bytes(), 8227 } 8228 } 8229 8230 return output 8231} 8232 8233func awsAwsquery_deserializeErrorDBSubnetQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8234 output := &types.DBSubnetQuotaExceededFault{} 8235 var buff [1024]byte 8236 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8237 body := io.TeeReader(errorBody, ringBuffer) 8238 rootDecoder := xml.NewDecoder(body) 8239 t, err := smithyxml.FetchRootElement(rootDecoder) 8240 if err == io.EOF { 8241 return output 8242 } 8243 if err != nil { 8244 var snapshot bytes.Buffer 8245 io.Copy(&snapshot, ringBuffer) 8246 return &smithy.DeserializationError{ 8247 Err: fmt.Errorf("failed to decode response body, %w", err), 8248 Snapshot: snapshot.Bytes(), 8249 } 8250 } 8251 8252 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8253 t, err = decoder.GetElement("Error") 8254 if err != nil { 8255 var snapshot bytes.Buffer 8256 io.Copy(&snapshot, ringBuffer) 8257 return &smithy.DeserializationError{ 8258 Err: fmt.Errorf("failed to decode response body, %w", err), 8259 Snapshot: snapshot.Bytes(), 8260 } 8261 } 8262 8263 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8264 err = awsAwsquery_deserializeDocumentDBSubnetQuotaExceededFault(&output, decoder) 8265 if err != nil { 8266 var snapshot bytes.Buffer 8267 io.Copy(&snapshot, ringBuffer) 8268 return &smithy.DeserializationError{ 8269 Err: fmt.Errorf("failed to decode response body, %w", err), 8270 Snapshot: snapshot.Bytes(), 8271 } 8272 } 8273 8274 return output 8275} 8276 8277func awsAwsquery_deserializeErrorDBUpgradeDependencyFailureFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8278 output := &types.DBUpgradeDependencyFailureFault{} 8279 var buff [1024]byte 8280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8281 body := io.TeeReader(errorBody, ringBuffer) 8282 rootDecoder := xml.NewDecoder(body) 8283 t, err := smithyxml.FetchRootElement(rootDecoder) 8284 if err == io.EOF { 8285 return output 8286 } 8287 if err != nil { 8288 var snapshot bytes.Buffer 8289 io.Copy(&snapshot, ringBuffer) 8290 return &smithy.DeserializationError{ 8291 Err: fmt.Errorf("failed to decode response body, %w", err), 8292 Snapshot: snapshot.Bytes(), 8293 } 8294 } 8295 8296 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8297 t, err = decoder.GetElement("Error") 8298 if err != nil { 8299 var snapshot bytes.Buffer 8300 io.Copy(&snapshot, ringBuffer) 8301 return &smithy.DeserializationError{ 8302 Err: fmt.Errorf("failed to decode response body, %w", err), 8303 Snapshot: snapshot.Bytes(), 8304 } 8305 } 8306 8307 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8308 err = awsAwsquery_deserializeDocumentDBUpgradeDependencyFailureFault(&output, decoder) 8309 if err != nil { 8310 var snapshot bytes.Buffer 8311 io.Copy(&snapshot, ringBuffer) 8312 return &smithy.DeserializationError{ 8313 Err: fmt.Errorf("failed to decode response body, %w", err), 8314 Snapshot: snapshot.Bytes(), 8315 } 8316 } 8317 8318 return output 8319} 8320 8321func awsAwsquery_deserializeErrorDomainNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8322 output := &types.DomainNotFoundFault{} 8323 var buff [1024]byte 8324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8325 body := io.TeeReader(errorBody, ringBuffer) 8326 rootDecoder := xml.NewDecoder(body) 8327 t, err := smithyxml.FetchRootElement(rootDecoder) 8328 if err == io.EOF { 8329 return output 8330 } 8331 if err != nil { 8332 var snapshot bytes.Buffer 8333 io.Copy(&snapshot, ringBuffer) 8334 return &smithy.DeserializationError{ 8335 Err: fmt.Errorf("failed to decode response body, %w", err), 8336 Snapshot: snapshot.Bytes(), 8337 } 8338 } 8339 8340 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8341 t, err = decoder.GetElement("Error") 8342 if err != nil { 8343 var snapshot bytes.Buffer 8344 io.Copy(&snapshot, ringBuffer) 8345 return &smithy.DeserializationError{ 8346 Err: fmt.Errorf("failed to decode response body, %w", err), 8347 Snapshot: snapshot.Bytes(), 8348 } 8349 } 8350 8351 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8352 err = awsAwsquery_deserializeDocumentDomainNotFoundFault(&output, decoder) 8353 if err != nil { 8354 var snapshot bytes.Buffer 8355 io.Copy(&snapshot, ringBuffer) 8356 return &smithy.DeserializationError{ 8357 Err: fmt.Errorf("failed to decode response body, %w", err), 8358 Snapshot: snapshot.Bytes(), 8359 } 8360 } 8361 8362 return output 8363} 8364 8365func awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8366 output := &types.EventSubscriptionQuotaExceededFault{} 8367 var buff [1024]byte 8368 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8369 body := io.TeeReader(errorBody, ringBuffer) 8370 rootDecoder := xml.NewDecoder(body) 8371 t, err := smithyxml.FetchRootElement(rootDecoder) 8372 if err == io.EOF { 8373 return output 8374 } 8375 if err != nil { 8376 var snapshot bytes.Buffer 8377 io.Copy(&snapshot, ringBuffer) 8378 return &smithy.DeserializationError{ 8379 Err: fmt.Errorf("failed to decode response body, %w", err), 8380 Snapshot: snapshot.Bytes(), 8381 } 8382 } 8383 8384 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8385 t, err = decoder.GetElement("Error") 8386 if err != nil { 8387 var snapshot bytes.Buffer 8388 io.Copy(&snapshot, ringBuffer) 8389 return &smithy.DeserializationError{ 8390 Err: fmt.Errorf("failed to decode response body, %w", err), 8391 Snapshot: snapshot.Bytes(), 8392 } 8393 } 8394 8395 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8396 err = awsAwsquery_deserializeDocumentEventSubscriptionQuotaExceededFault(&output, decoder) 8397 if err != nil { 8398 var snapshot bytes.Buffer 8399 io.Copy(&snapshot, ringBuffer) 8400 return &smithy.DeserializationError{ 8401 Err: fmt.Errorf("failed to decode response body, %w", err), 8402 Snapshot: snapshot.Bytes(), 8403 } 8404 } 8405 8406 return output 8407} 8408 8409func awsAwsquery_deserializeErrorInstanceQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8410 output := &types.InstanceQuotaExceededFault{} 8411 var buff [1024]byte 8412 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8413 body := io.TeeReader(errorBody, ringBuffer) 8414 rootDecoder := xml.NewDecoder(body) 8415 t, err := smithyxml.FetchRootElement(rootDecoder) 8416 if err == io.EOF { 8417 return output 8418 } 8419 if err != nil { 8420 var snapshot bytes.Buffer 8421 io.Copy(&snapshot, ringBuffer) 8422 return &smithy.DeserializationError{ 8423 Err: fmt.Errorf("failed to decode response body, %w", err), 8424 Snapshot: snapshot.Bytes(), 8425 } 8426 } 8427 8428 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8429 t, err = decoder.GetElement("Error") 8430 if err != nil { 8431 var snapshot bytes.Buffer 8432 io.Copy(&snapshot, ringBuffer) 8433 return &smithy.DeserializationError{ 8434 Err: fmt.Errorf("failed to decode response body, %w", err), 8435 Snapshot: snapshot.Bytes(), 8436 } 8437 } 8438 8439 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8440 err = awsAwsquery_deserializeDocumentInstanceQuotaExceededFault(&output, decoder) 8441 if err != nil { 8442 var snapshot bytes.Buffer 8443 io.Copy(&snapshot, ringBuffer) 8444 return &smithy.DeserializationError{ 8445 Err: fmt.Errorf("failed to decode response body, %w", err), 8446 Snapshot: snapshot.Bytes(), 8447 } 8448 } 8449 8450 return output 8451} 8452 8453func awsAwsquery_deserializeErrorInsufficientDBClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8454 output := &types.InsufficientDBClusterCapacityFault{} 8455 var buff [1024]byte 8456 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8457 body := io.TeeReader(errorBody, ringBuffer) 8458 rootDecoder := xml.NewDecoder(body) 8459 t, err := smithyxml.FetchRootElement(rootDecoder) 8460 if err == io.EOF { 8461 return output 8462 } 8463 if err != nil { 8464 var snapshot bytes.Buffer 8465 io.Copy(&snapshot, ringBuffer) 8466 return &smithy.DeserializationError{ 8467 Err: fmt.Errorf("failed to decode response body, %w", err), 8468 Snapshot: snapshot.Bytes(), 8469 } 8470 } 8471 8472 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8473 t, err = decoder.GetElement("Error") 8474 if err != nil { 8475 var snapshot bytes.Buffer 8476 io.Copy(&snapshot, ringBuffer) 8477 return &smithy.DeserializationError{ 8478 Err: fmt.Errorf("failed to decode response body, %w", err), 8479 Snapshot: snapshot.Bytes(), 8480 } 8481 } 8482 8483 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8484 err = awsAwsquery_deserializeDocumentInsufficientDBClusterCapacityFault(&output, decoder) 8485 if err != nil { 8486 var snapshot bytes.Buffer 8487 io.Copy(&snapshot, ringBuffer) 8488 return &smithy.DeserializationError{ 8489 Err: fmt.Errorf("failed to decode response body, %w", err), 8490 Snapshot: snapshot.Bytes(), 8491 } 8492 } 8493 8494 return output 8495} 8496 8497func awsAwsquery_deserializeErrorInsufficientDBInstanceCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8498 output := &types.InsufficientDBInstanceCapacityFault{} 8499 var buff [1024]byte 8500 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8501 body := io.TeeReader(errorBody, ringBuffer) 8502 rootDecoder := xml.NewDecoder(body) 8503 t, err := smithyxml.FetchRootElement(rootDecoder) 8504 if err == io.EOF { 8505 return output 8506 } 8507 if err != nil { 8508 var snapshot bytes.Buffer 8509 io.Copy(&snapshot, ringBuffer) 8510 return &smithy.DeserializationError{ 8511 Err: fmt.Errorf("failed to decode response body, %w", err), 8512 Snapshot: snapshot.Bytes(), 8513 } 8514 } 8515 8516 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8517 t, err = decoder.GetElement("Error") 8518 if err != nil { 8519 var snapshot bytes.Buffer 8520 io.Copy(&snapshot, ringBuffer) 8521 return &smithy.DeserializationError{ 8522 Err: fmt.Errorf("failed to decode response body, %w", err), 8523 Snapshot: snapshot.Bytes(), 8524 } 8525 } 8526 8527 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8528 err = awsAwsquery_deserializeDocumentInsufficientDBInstanceCapacityFault(&output, decoder) 8529 if err != nil { 8530 var snapshot bytes.Buffer 8531 io.Copy(&snapshot, ringBuffer) 8532 return &smithy.DeserializationError{ 8533 Err: fmt.Errorf("failed to decode response body, %w", err), 8534 Snapshot: snapshot.Bytes(), 8535 } 8536 } 8537 8538 return output 8539} 8540 8541func awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8542 output := &types.InsufficientStorageClusterCapacityFault{} 8543 var buff [1024]byte 8544 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8545 body := io.TeeReader(errorBody, ringBuffer) 8546 rootDecoder := xml.NewDecoder(body) 8547 t, err := smithyxml.FetchRootElement(rootDecoder) 8548 if err == io.EOF { 8549 return output 8550 } 8551 if err != nil { 8552 var snapshot bytes.Buffer 8553 io.Copy(&snapshot, ringBuffer) 8554 return &smithy.DeserializationError{ 8555 Err: fmt.Errorf("failed to decode response body, %w", err), 8556 Snapshot: snapshot.Bytes(), 8557 } 8558 } 8559 8560 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8561 t, err = decoder.GetElement("Error") 8562 if err != nil { 8563 var snapshot bytes.Buffer 8564 io.Copy(&snapshot, ringBuffer) 8565 return &smithy.DeserializationError{ 8566 Err: fmt.Errorf("failed to decode response body, %w", err), 8567 Snapshot: snapshot.Bytes(), 8568 } 8569 } 8570 8571 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8572 err = awsAwsquery_deserializeDocumentInsufficientStorageClusterCapacityFault(&output, decoder) 8573 if err != nil { 8574 var snapshot bytes.Buffer 8575 io.Copy(&snapshot, ringBuffer) 8576 return &smithy.DeserializationError{ 8577 Err: fmt.Errorf("failed to decode response body, %w", err), 8578 Snapshot: snapshot.Bytes(), 8579 } 8580 } 8581 8582 return output 8583} 8584 8585func awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8586 output := &types.InvalidDBClusterEndpointStateFault{} 8587 var buff [1024]byte 8588 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8589 body := io.TeeReader(errorBody, ringBuffer) 8590 rootDecoder := xml.NewDecoder(body) 8591 t, err := smithyxml.FetchRootElement(rootDecoder) 8592 if err == io.EOF { 8593 return output 8594 } 8595 if err != nil { 8596 var snapshot bytes.Buffer 8597 io.Copy(&snapshot, ringBuffer) 8598 return &smithy.DeserializationError{ 8599 Err: fmt.Errorf("failed to decode response body, %w", err), 8600 Snapshot: snapshot.Bytes(), 8601 } 8602 } 8603 8604 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8605 t, err = decoder.GetElement("Error") 8606 if err != nil { 8607 var snapshot bytes.Buffer 8608 io.Copy(&snapshot, ringBuffer) 8609 return &smithy.DeserializationError{ 8610 Err: fmt.Errorf("failed to decode response body, %w", err), 8611 Snapshot: snapshot.Bytes(), 8612 } 8613 } 8614 8615 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8616 err = awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(&output, decoder) 8617 if err != nil { 8618 var snapshot bytes.Buffer 8619 io.Copy(&snapshot, ringBuffer) 8620 return &smithy.DeserializationError{ 8621 Err: fmt.Errorf("failed to decode response body, %w", err), 8622 Snapshot: snapshot.Bytes(), 8623 } 8624 } 8625 8626 return output 8627} 8628 8629func awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8630 output := &types.InvalidDBClusterSnapshotStateFault{} 8631 var buff [1024]byte 8632 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8633 body := io.TeeReader(errorBody, ringBuffer) 8634 rootDecoder := xml.NewDecoder(body) 8635 t, err := smithyxml.FetchRootElement(rootDecoder) 8636 if err == io.EOF { 8637 return output 8638 } 8639 if err != nil { 8640 var snapshot bytes.Buffer 8641 io.Copy(&snapshot, ringBuffer) 8642 return &smithy.DeserializationError{ 8643 Err: fmt.Errorf("failed to decode response body, %w", err), 8644 Snapshot: snapshot.Bytes(), 8645 } 8646 } 8647 8648 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8649 t, err = decoder.GetElement("Error") 8650 if err != nil { 8651 var snapshot bytes.Buffer 8652 io.Copy(&snapshot, ringBuffer) 8653 return &smithy.DeserializationError{ 8654 Err: fmt.Errorf("failed to decode response body, %w", err), 8655 Snapshot: snapshot.Bytes(), 8656 } 8657 } 8658 8659 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8660 err = awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(&output, decoder) 8661 if err != nil { 8662 var snapshot bytes.Buffer 8663 io.Copy(&snapshot, ringBuffer) 8664 return &smithy.DeserializationError{ 8665 Err: fmt.Errorf("failed to decode response body, %w", err), 8666 Snapshot: snapshot.Bytes(), 8667 } 8668 } 8669 8670 return output 8671} 8672 8673func awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8674 output := &types.InvalidDBClusterStateFault{} 8675 var buff [1024]byte 8676 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8677 body := io.TeeReader(errorBody, ringBuffer) 8678 rootDecoder := xml.NewDecoder(body) 8679 t, err := smithyxml.FetchRootElement(rootDecoder) 8680 if err == io.EOF { 8681 return output 8682 } 8683 if err != nil { 8684 var snapshot bytes.Buffer 8685 io.Copy(&snapshot, ringBuffer) 8686 return &smithy.DeserializationError{ 8687 Err: fmt.Errorf("failed to decode response body, %w", err), 8688 Snapshot: snapshot.Bytes(), 8689 } 8690 } 8691 8692 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8693 t, err = decoder.GetElement("Error") 8694 if err != nil { 8695 var snapshot bytes.Buffer 8696 io.Copy(&snapshot, ringBuffer) 8697 return &smithy.DeserializationError{ 8698 Err: fmt.Errorf("failed to decode response body, %w", err), 8699 Snapshot: snapshot.Bytes(), 8700 } 8701 } 8702 8703 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8704 err = awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(&output, decoder) 8705 if err != nil { 8706 var snapshot bytes.Buffer 8707 io.Copy(&snapshot, ringBuffer) 8708 return &smithy.DeserializationError{ 8709 Err: fmt.Errorf("failed to decode response body, %w", err), 8710 Snapshot: snapshot.Bytes(), 8711 } 8712 } 8713 8714 return output 8715} 8716 8717func awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8718 output := &types.InvalidDBInstanceStateFault{} 8719 var buff [1024]byte 8720 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8721 body := io.TeeReader(errorBody, ringBuffer) 8722 rootDecoder := xml.NewDecoder(body) 8723 t, err := smithyxml.FetchRootElement(rootDecoder) 8724 if err == io.EOF { 8725 return output 8726 } 8727 if err != nil { 8728 var snapshot bytes.Buffer 8729 io.Copy(&snapshot, ringBuffer) 8730 return &smithy.DeserializationError{ 8731 Err: fmt.Errorf("failed to decode response body, %w", err), 8732 Snapshot: snapshot.Bytes(), 8733 } 8734 } 8735 8736 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8737 t, err = decoder.GetElement("Error") 8738 if err != nil { 8739 var snapshot bytes.Buffer 8740 io.Copy(&snapshot, ringBuffer) 8741 return &smithy.DeserializationError{ 8742 Err: fmt.Errorf("failed to decode response body, %w", err), 8743 Snapshot: snapshot.Bytes(), 8744 } 8745 } 8746 8747 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8748 err = awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(&output, decoder) 8749 if err != nil { 8750 var snapshot bytes.Buffer 8751 io.Copy(&snapshot, ringBuffer) 8752 return &smithy.DeserializationError{ 8753 Err: fmt.Errorf("failed to decode response body, %w", err), 8754 Snapshot: snapshot.Bytes(), 8755 } 8756 } 8757 8758 return output 8759} 8760 8761func awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8762 output := &types.InvalidDBParameterGroupStateFault{} 8763 var buff [1024]byte 8764 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8765 body := io.TeeReader(errorBody, ringBuffer) 8766 rootDecoder := xml.NewDecoder(body) 8767 t, err := smithyxml.FetchRootElement(rootDecoder) 8768 if err == io.EOF { 8769 return output 8770 } 8771 if err != nil { 8772 var snapshot bytes.Buffer 8773 io.Copy(&snapshot, ringBuffer) 8774 return &smithy.DeserializationError{ 8775 Err: fmt.Errorf("failed to decode response body, %w", err), 8776 Snapshot: snapshot.Bytes(), 8777 } 8778 } 8779 8780 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8781 t, err = decoder.GetElement("Error") 8782 if err != nil { 8783 var snapshot bytes.Buffer 8784 io.Copy(&snapshot, ringBuffer) 8785 return &smithy.DeserializationError{ 8786 Err: fmt.Errorf("failed to decode response body, %w", err), 8787 Snapshot: snapshot.Bytes(), 8788 } 8789 } 8790 8791 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8792 err = awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(&output, decoder) 8793 if err != nil { 8794 var snapshot bytes.Buffer 8795 io.Copy(&snapshot, ringBuffer) 8796 return &smithy.DeserializationError{ 8797 Err: fmt.Errorf("failed to decode response body, %w", err), 8798 Snapshot: snapshot.Bytes(), 8799 } 8800 } 8801 8802 return output 8803} 8804 8805func awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8806 output := &types.InvalidDBSecurityGroupStateFault{} 8807 var buff [1024]byte 8808 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8809 body := io.TeeReader(errorBody, ringBuffer) 8810 rootDecoder := xml.NewDecoder(body) 8811 t, err := smithyxml.FetchRootElement(rootDecoder) 8812 if err == io.EOF { 8813 return output 8814 } 8815 if err != nil { 8816 var snapshot bytes.Buffer 8817 io.Copy(&snapshot, ringBuffer) 8818 return &smithy.DeserializationError{ 8819 Err: fmt.Errorf("failed to decode response body, %w", err), 8820 Snapshot: snapshot.Bytes(), 8821 } 8822 } 8823 8824 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8825 t, err = decoder.GetElement("Error") 8826 if err != nil { 8827 var snapshot bytes.Buffer 8828 io.Copy(&snapshot, ringBuffer) 8829 return &smithy.DeserializationError{ 8830 Err: fmt.Errorf("failed to decode response body, %w", err), 8831 Snapshot: snapshot.Bytes(), 8832 } 8833 } 8834 8835 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8836 err = awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(&output, decoder) 8837 if err != nil { 8838 var snapshot bytes.Buffer 8839 io.Copy(&snapshot, ringBuffer) 8840 return &smithy.DeserializationError{ 8841 Err: fmt.Errorf("failed to decode response body, %w", err), 8842 Snapshot: snapshot.Bytes(), 8843 } 8844 } 8845 8846 return output 8847} 8848 8849func awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8850 output := &types.InvalidDBSnapshotStateFault{} 8851 var buff [1024]byte 8852 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8853 body := io.TeeReader(errorBody, ringBuffer) 8854 rootDecoder := xml.NewDecoder(body) 8855 t, err := smithyxml.FetchRootElement(rootDecoder) 8856 if err == io.EOF { 8857 return output 8858 } 8859 if err != nil { 8860 var snapshot bytes.Buffer 8861 io.Copy(&snapshot, ringBuffer) 8862 return &smithy.DeserializationError{ 8863 Err: fmt.Errorf("failed to decode response body, %w", err), 8864 Snapshot: snapshot.Bytes(), 8865 } 8866 } 8867 8868 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8869 t, err = decoder.GetElement("Error") 8870 if err != nil { 8871 var snapshot bytes.Buffer 8872 io.Copy(&snapshot, ringBuffer) 8873 return &smithy.DeserializationError{ 8874 Err: fmt.Errorf("failed to decode response body, %w", err), 8875 Snapshot: snapshot.Bytes(), 8876 } 8877 } 8878 8879 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8880 err = awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(&output, decoder) 8881 if err != nil { 8882 var snapshot bytes.Buffer 8883 io.Copy(&snapshot, ringBuffer) 8884 return &smithy.DeserializationError{ 8885 Err: fmt.Errorf("failed to decode response body, %w", err), 8886 Snapshot: snapshot.Bytes(), 8887 } 8888 } 8889 8890 return output 8891} 8892 8893func awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8894 output := &types.InvalidDBSubnetGroupStateFault{} 8895 var buff [1024]byte 8896 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8897 body := io.TeeReader(errorBody, ringBuffer) 8898 rootDecoder := xml.NewDecoder(body) 8899 t, err := smithyxml.FetchRootElement(rootDecoder) 8900 if err == io.EOF { 8901 return output 8902 } 8903 if err != nil { 8904 var snapshot bytes.Buffer 8905 io.Copy(&snapshot, ringBuffer) 8906 return &smithy.DeserializationError{ 8907 Err: fmt.Errorf("failed to decode response body, %w", err), 8908 Snapshot: snapshot.Bytes(), 8909 } 8910 } 8911 8912 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8913 t, err = decoder.GetElement("Error") 8914 if err != nil { 8915 var snapshot bytes.Buffer 8916 io.Copy(&snapshot, ringBuffer) 8917 return &smithy.DeserializationError{ 8918 Err: fmt.Errorf("failed to decode response body, %w", err), 8919 Snapshot: snapshot.Bytes(), 8920 } 8921 } 8922 8923 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8924 err = awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(&output, decoder) 8925 if err != nil { 8926 var snapshot bytes.Buffer 8927 io.Copy(&snapshot, ringBuffer) 8928 return &smithy.DeserializationError{ 8929 Err: fmt.Errorf("failed to decode response body, %w", err), 8930 Snapshot: snapshot.Bytes(), 8931 } 8932 } 8933 8934 return output 8935} 8936 8937func awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8938 output := &types.InvalidDBSubnetStateFault{} 8939 var buff [1024]byte 8940 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8941 body := io.TeeReader(errorBody, ringBuffer) 8942 rootDecoder := xml.NewDecoder(body) 8943 t, err := smithyxml.FetchRootElement(rootDecoder) 8944 if err == io.EOF { 8945 return output 8946 } 8947 if err != nil { 8948 var snapshot bytes.Buffer 8949 io.Copy(&snapshot, ringBuffer) 8950 return &smithy.DeserializationError{ 8951 Err: fmt.Errorf("failed to decode response body, %w", err), 8952 Snapshot: snapshot.Bytes(), 8953 } 8954 } 8955 8956 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8957 t, err = decoder.GetElement("Error") 8958 if err != nil { 8959 var snapshot bytes.Buffer 8960 io.Copy(&snapshot, ringBuffer) 8961 return &smithy.DeserializationError{ 8962 Err: fmt.Errorf("failed to decode response body, %w", err), 8963 Snapshot: snapshot.Bytes(), 8964 } 8965 } 8966 8967 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8968 err = awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(&output, decoder) 8969 if err != nil { 8970 var snapshot bytes.Buffer 8971 io.Copy(&snapshot, ringBuffer) 8972 return &smithy.DeserializationError{ 8973 Err: fmt.Errorf("failed to decode response body, %w", err), 8974 Snapshot: snapshot.Bytes(), 8975 } 8976 } 8977 8978 return output 8979} 8980 8981func awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8982 output := &types.InvalidEventSubscriptionStateFault{} 8983 var buff [1024]byte 8984 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8985 body := io.TeeReader(errorBody, ringBuffer) 8986 rootDecoder := xml.NewDecoder(body) 8987 t, err := smithyxml.FetchRootElement(rootDecoder) 8988 if err == io.EOF { 8989 return output 8990 } 8991 if err != nil { 8992 var snapshot bytes.Buffer 8993 io.Copy(&snapshot, ringBuffer) 8994 return &smithy.DeserializationError{ 8995 Err: fmt.Errorf("failed to decode response body, %w", err), 8996 Snapshot: snapshot.Bytes(), 8997 } 8998 } 8999 9000 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9001 t, err = decoder.GetElement("Error") 9002 if err != nil { 9003 var snapshot bytes.Buffer 9004 io.Copy(&snapshot, ringBuffer) 9005 return &smithy.DeserializationError{ 9006 Err: fmt.Errorf("failed to decode response body, %w", err), 9007 Snapshot: snapshot.Bytes(), 9008 } 9009 } 9010 9011 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9012 err = awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(&output, decoder) 9013 if err != nil { 9014 var snapshot bytes.Buffer 9015 io.Copy(&snapshot, ringBuffer) 9016 return &smithy.DeserializationError{ 9017 Err: fmt.Errorf("failed to decode response body, %w", err), 9018 Snapshot: snapshot.Bytes(), 9019 } 9020 } 9021 9022 return output 9023} 9024 9025func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9026 output := &types.InvalidRestoreFault{} 9027 var buff [1024]byte 9028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9029 body := io.TeeReader(errorBody, ringBuffer) 9030 rootDecoder := xml.NewDecoder(body) 9031 t, err := smithyxml.FetchRootElement(rootDecoder) 9032 if err == io.EOF { 9033 return output 9034 } 9035 if err != nil { 9036 var snapshot bytes.Buffer 9037 io.Copy(&snapshot, ringBuffer) 9038 return &smithy.DeserializationError{ 9039 Err: fmt.Errorf("failed to decode response body, %w", err), 9040 Snapshot: snapshot.Bytes(), 9041 } 9042 } 9043 9044 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9045 t, err = decoder.GetElement("Error") 9046 if err != nil { 9047 var snapshot bytes.Buffer 9048 io.Copy(&snapshot, ringBuffer) 9049 return &smithy.DeserializationError{ 9050 Err: fmt.Errorf("failed to decode response body, %w", err), 9051 Snapshot: snapshot.Bytes(), 9052 } 9053 } 9054 9055 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9056 err = awsAwsquery_deserializeDocumentInvalidRestoreFault(&output, decoder) 9057 if err != nil { 9058 var snapshot bytes.Buffer 9059 io.Copy(&snapshot, ringBuffer) 9060 return &smithy.DeserializationError{ 9061 Err: fmt.Errorf("failed to decode response body, %w", err), 9062 Snapshot: snapshot.Bytes(), 9063 } 9064 } 9065 9066 return output 9067} 9068 9069func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9070 output := &types.InvalidSubnet{} 9071 var buff [1024]byte 9072 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9073 body := io.TeeReader(errorBody, ringBuffer) 9074 rootDecoder := xml.NewDecoder(body) 9075 t, err := smithyxml.FetchRootElement(rootDecoder) 9076 if err == io.EOF { 9077 return output 9078 } 9079 if err != nil { 9080 var snapshot bytes.Buffer 9081 io.Copy(&snapshot, ringBuffer) 9082 return &smithy.DeserializationError{ 9083 Err: fmt.Errorf("failed to decode response body, %w", err), 9084 Snapshot: snapshot.Bytes(), 9085 } 9086 } 9087 9088 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9089 t, err = decoder.GetElement("Error") 9090 if err != nil { 9091 var snapshot bytes.Buffer 9092 io.Copy(&snapshot, ringBuffer) 9093 return &smithy.DeserializationError{ 9094 Err: fmt.Errorf("failed to decode response body, %w", err), 9095 Snapshot: snapshot.Bytes(), 9096 } 9097 } 9098 9099 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9100 err = awsAwsquery_deserializeDocumentInvalidSubnet(&output, decoder) 9101 if err != nil { 9102 var snapshot bytes.Buffer 9103 io.Copy(&snapshot, ringBuffer) 9104 return &smithy.DeserializationError{ 9105 Err: fmt.Errorf("failed to decode response body, %w", err), 9106 Snapshot: snapshot.Bytes(), 9107 } 9108 } 9109 9110 return output 9111} 9112 9113func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9114 output := &types.InvalidVPCNetworkStateFault{} 9115 var buff [1024]byte 9116 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9117 body := io.TeeReader(errorBody, ringBuffer) 9118 rootDecoder := xml.NewDecoder(body) 9119 t, err := smithyxml.FetchRootElement(rootDecoder) 9120 if err == io.EOF { 9121 return output 9122 } 9123 if err != nil { 9124 var snapshot bytes.Buffer 9125 io.Copy(&snapshot, ringBuffer) 9126 return &smithy.DeserializationError{ 9127 Err: fmt.Errorf("failed to decode response body, %w", err), 9128 Snapshot: snapshot.Bytes(), 9129 } 9130 } 9131 9132 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9133 t, err = decoder.GetElement("Error") 9134 if err != nil { 9135 var snapshot bytes.Buffer 9136 io.Copy(&snapshot, ringBuffer) 9137 return &smithy.DeserializationError{ 9138 Err: fmt.Errorf("failed to decode response body, %w", err), 9139 Snapshot: snapshot.Bytes(), 9140 } 9141 } 9142 9143 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9144 err = awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(&output, decoder) 9145 if err != nil { 9146 var snapshot bytes.Buffer 9147 io.Copy(&snapshot, ringBuffer) 9148 return &smithy.DeserializationError{ 9149 Err: fmt.Errorf("failed to decode response body, %w", err), 9150 Snapshot: snapshot.Bytes(), 9151 } 9152 } 9153 9154 return output 9155} 9156 9157func awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9158 output := &types.KMSKeyNotAccessibleFault{} 9159 var buff [1024]byte 9160 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9161 body := io.TeeReader(errorBody, ringBuffer) 9162 rootDecoder := xml.NewDecoder(body) 9163 t, err := smithyxml.FetchRootElement(rootDecoder) 9164 if err == io.EOF { 9165 return output 9166 } 9167 if err != nil { 9168 var snapshot bytes.Buffer 9169 io.Copy(&snapshot, ringBuffer) 9170 return &smithy.DeserializationError{ 9171 Err: fmt.Errorf("failed to decode response body, %w", err), 9172 Snapshot: snapshot.Bytes(), 9173 } 9174 } 9175 9176 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9177 t, err = decoder.GetElement("Error") 9178 if err != nil { 9179 var snapshot bytes.Buffer 9180 io.Copy(&snapshot, ringBuffer) 9181 return &smithy.DeserializationError{ 9182 Err: fmt.Errorf("failed to decode response body, %w", err), 9183 Snapshot: snapshot.Bytes(), 9184 } 9185 } 9186 9187 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9188 err = awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(&output, decoder) 9189 if err != nil { 9190 var snapshot bytes.Buffer 9191 io.Copy(&snapshot, ringBuffer) 9192 return &smithy.DeserializationError{ 9193 Err: fmt.Errorf("failed to decode response body, %w", err), 9194 Snapshot: snapshot.Bytes(), 9195 } 9196 } 9197 9198 return output 9199} 9200 9201func awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9202 output := &types.OptionGroupNotFoundFault{} 9203 var buff [1024]byte 9204 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9205 body := io.TeeReader(errorBody, ringBuffer) 9206 rootDecoder := xml.NewDecoder(body) 9207 t, err := smithyxml.FetchRootElement(rootDecoder) 9208 if err == io.EOF { 9209 return output 9210 } 9211 if err != nil { 9212 var snapshot bytes.Buffer 9213 io.Copy(&snapshot, ringBuffer) 9214 return &smithy.DeserializationError{ 9215 Err: fmt.Errorf("failed to decode response body, %w", err), 9216 Snapshot: snapshot.Bytes(), 9217 } 9218 } 9219 9220 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9221 t, err = decoder.GetElement("Error") 9222 if err != nil { 9223 var snapshot bytes.Buffer 9224 io.Copy(&snapshot, ringBuffer) 9225 return &smithy.DeserializationError{ 9226 Err: fmt.Errorf("failed to decode response body, %w", err), 9227 Snapshot: snapshot.Bytes(), 9228 } 9229 } 9230 9231 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9232 err = awsAwsquery_deserializeDocumentOptionGroupNotFoundFault(&output, decoder) 9233 if err != nil { 9234 var snapshot bytes.Buffer 9235 io.Copy(&snapshot, ringBuffer) 9236 return &smithy.DeserializationError{ 9237 Err: fmt.Errorf("failed to decode response body, %w", err), 9238 Snapshot: snapshot.Bytes(), 9239 } 9240 } 9241 9242 return output 9243} 9244 9245func awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9246 output := &types.ProvisionedIopsNotAvailableInAZFault{} 9247 var buff [1024]byte 9248 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9249 body := io.TeeReader(errorBody, ringBuffer) 9250 rootDecoder := xml.NewDecoder(body) 9251 t, err := smithyxml.FetchRootElement(rootDecoder) 9252 if err == io.EOF { 9253 return output 9254 } 9255 if err != nil { 9256 var snapshot bytes.Buffer 9257 io.Copy(&snapshot, ringBuffer) 9258 return &smithy.DeserializationError{ 9259 Err: fmt.Errorf("failed to decode response body, %w", err), 9260 Snapshot: snapshot.Bytes(), 9261 } 9262 } 9263 9264 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9265 t, err = decoder.GetElement("Error") 9266 if err != nil { 9267 var snapshot bytes.Buffer 9268 io.Copy(&snapshot, ringBuffer) 9269 return &smithy.DeserializationError{ 9270 Err: fmt.Errorf("failed to decode response body, %w", err), 9271 Snapshot: snapshot.Bytes(), 9272 } 9273 } 9274 9275 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9276 err = awsAwsquery_deserializeDocumentProvisionedIopsNotAvailableInAZFault(&output, decoder) 9277 if err != nil { 9278 var snapshot bytes.Buffer 9279 io.Copy(&snapshot, ringBuffer) 9280 return &smithy.DeserializationError{ 9281 Err: fmt.Errorf("failed to decode response body, %w", err), 9282 Snapshot: snapshot.Bytes(), 9283 } 9284 } 9285 9286 return output 9287} 9288 9289func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9290 output := &types.ResourceNotFoundFault{} 9291 var buff [1024]byte 9292 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9293 body := io.TeeReader(errorBody, ringBuffer) 9294 rootDecoder := xml.NewDecoder(body) 9295 t, err := smithyxml.FetchRootElement(rootDecoder) 9296 if err == io.EOF { 9297 return output 9298 } 9299 if err != nil { 9300 var snapshot bytes.Buffer 9301 io.Copy(&snapshot, ringBuffer) 9302 return &smithy.DeserializationError{ 9303 Err: fmt.Errorf("failed to decode response body, %w", err), 9304 Snapshot: snapshot.Bytes(), 9305 } 9306 } 9307 9308 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9309 t, err = decoder.GetElement("Error") 9310 if err != nil { 9311 var snapshot bytes.Buffer 9312 io.Copy(&snapshot, ringBuffer) 9313 return &smithy.DeserializationError{ 9314 Err: fmt.Errorf("failed to decode response body, %w", err), 9315 Snapshot: snapshot.Bytes(), 9316 } 9317 } 9318 9319 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9320 err = awsAwsquery_deserializeDocumentResourceNotFoundFault(&output, decoder) 9321 if err != nil { 9322 var snapshot bytes.Buffer 9323 io.Copy(&snapshot, ringBuffer) 9324 return &smithy.DeserializationError{ 9325 Err: fmt.Errorf("failed to decode response body, %w", err), 9326 Snapshot: snapshot.Bytes(), 9327 } 9328 } 9329 9330 return output 9331} 9332 9333func awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9334 output := &types.SharedSnapshotQuotaExceededFault{} 9335 var buff [1024]byte 9336 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9337 body := io.TeeReader(errorBody, ringBuffer) 9338 rootDecoder := xml.NewDecoder(body) 9339 t, err := smithyxml.FetchRootElement(rootDecoder) 9340 if err == io.EOF { 9341 return output 9342 } 9343 if err != nil { 9344 var snapshot bytes.Buffer 9345 io.Copy(&snapshot, ringBuffer) 9346 return &smithy.DeserializationError{ 9347 Err: fmt.Errorf("failed to decode response body, %w", err), 9348 Snapshot: snapshot.Bytes(), 9349 } 9350 } 9351 9352 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9353 t, err = decoder.GetElement("Error") 9354 if err != nil { 9355 var snapshot bytes.Buffer 9356 io.Copy(&snapshot, ringBuffer) 9357 return &smithy.DeserializationError{ 9358 Err: fmt.Errorf("failed to decode response body, %w", err), 9359 Snapshot: snapshot.Bytes(), 9360 } 9361 } 9362 9363 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9364 err = awsAwsquery_deserializeDocumentSharedSnapshotQuotaExceededFault(&output, decoder) 9365 if err != nil { 9366 var snapshot bytes.Buffer 9367 io.Copy(&snapshot, ringBuffer) 9368 return &smithy.DeserializationError{ 9369 Err: fmt.Errorf("failed to decode response body, %w", err), 9370 Snapshot: snapshot.Bytes(), 9371 } 9372 } 9373 9374 return output 9375} 9376 9377func awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9378 output := &types.SnapshotQuotaExceededFault{} 9379 var buff [1024]byte 9380 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9381 body := io.TeeReader(errorBody, ringBuffer) 9382 rootDecoder := xml.NewDecoder(body) 9383 t, err := smithyxml.FetchRootElement(rootDecoder) 9384 if err == io.EOF { 9385 return output 9386 } 9387 if err != nil { 9388 var snapshot bytes.Buffer 9389 io.Copy(&snapshot, ringBuffer) 9390 return &smithy.DeserializationError{ 9391 Err: fmt.Errorf("failed to decode response body, %w", err), 9392 Snapshot: snapshot.Bytes(), 9393 } 9394 } 9395 9396 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9397 t, err = decoder.GetElement("Error") 9398 if err != nil { 9399 var snapshot bytes.Buffer 9400 io.Copy(&snapshot, ringBuffer) 9401 return &smithy.DeserializationError{ 9402 Err: fmt.Errorf("failed to decode response body, %w", err), 9403 Snapshot: snapshot.Bytes(), 9404 } 9405 } 9406 9407 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9408 err = awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(&output, decoder) 9409 if err != nil { 9410 var snapshot bytes.Buffer 9411 io.Copy(&snapshot, ringBuffer) 9412 return &smithy.DeserializationError{ 9413 Err: fmt.Errorf("failed to decode response body, %w", err), 9414 Snapshot: snapshot.Bytes(), 9415 } 9416 } 9417 9418 return output 9419} 9420 9421func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9422 output := &types.SNSInvalidTopicFault{} 9423 var buff [1024]byte 9424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9425 body := io.TeeReader(errorBody, ringBuffer) 9426 rootDecoder := xml.NewDecoder(body) 9427 t, err := smithyxml.FetchRootElement(rootDecoder) 9428 if err == io.EOF { 9429 return output 9430 } 9431 if err != nil { 9432 var snapshot bytes.Buffer 9433 io.Copy(&snapshot, ringBuffer) 9434 return &smithy.DeserializationError{ 9435 Err: fmt.Errorf("failed to decode response body, %w", err), 9436 Snapshot: snapshot.Bytes(), 9437 } 9438 } 9439 9440 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9441 t, err = decoder.GetElement("Error") 9442 if err != nil { 9443 var snapshot bytes.Buffer 9444 io.Copy(&snapshot, ringBuffer) 9445 return &smithy.DeserializationError{ 9446 Err: fmt.Errorf("failed to decode response body, %w", err), 9447 Snapshot: snapshot.Bytes(), 9448 } 9449 } 9450 9451 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9452 err = awsAwsquery_deserializeDocumentSNSInvalidTopicFault(&output, decoder) 9453 if err != nil { 9454 var snapshot bytes.Buffer 9455 io.Copy(&snapshot, ringBuffer) 9456 return &smithy.DeserializationError{ 9457 Err: fmt.Errorf("failed to decode response body, %w", err), 9458 Snapshot: snapshot.Bytes(), 9459 } 9460 } 9461 9462 return output 9463} 9464 9465func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9466 output := &types.SNSNoAuthorizationFault{} 9467 var buff [1024]byte 9468 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9469 body := io.TeeReader(errorBody, ringBuffer) 9470 rootDecoder := xml.NewDecoder(body) 9471 t, err := smithyxml.FetchRootElement(rootDecoder) 9472 if err == io.EOF { 9473 return output 9474 } 9475 if err != nil { 9476 var snapshot bytes.Buffer 9477 io.Copy(&snapshot, ringBuffer) 9478 return &smithy.DeserializationError{ 9479 Err: fmt.Errorf("failed to decode response body, %w", err), 9480 Snapshot: snapshot.Bytes(), 9481 } 9482 } 9483 9484 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9485 t, err = decoder.GetElement("Error") 9486 if err != nil { 9487 var snapshot bytes.Buffer 9488 io.Copy(&snapshot, ringBuffer) 9489 return &smithy.DeserializationError{ 9490 Err: fmt.Errorf("failed to decode response body, %w", err), 9491 Snapshot: snapshot.Bytes(), 9492 } 9493 } 9494 9495 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9496 err = awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(&output, decoder) 9497 if err != nil { 9498 var snapshot bytes.Buffer 9499 io.Copy(&snapshot, ringBuffer) 9500 return &smithy.DeserializationError{ 9501 Err: fmt.Errorf("failed to decode response body, %w", err), 9502 Snapshot: snapshot.Bytes(), 9503 } 9504 } 9505 9506 return output 9507} 9508 9509func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9510 output := &types.SNSTopicArnNotFoundFault{} 9511 var buff [1024]byte 9512 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9513 body := io.TeeReader(errorBody, ringBuffer) 9514 rootDecoder := xml.NewDecoder(body) 9515 t, err := smithyxml.FetchRootElement(rootDecoder) 9516 if err == io.EOF { 9517 return output 9518 } 9519 if err != nil { 9520 var snapshot bytes.Buffer 9521 io.Copy(&snapshot, ringBuffer) 9522 return &smithy.DeserializationError{ 9523 Err: fmt.Errorf("failed to decode response body, %w", err), 9524 Snapshot: snapshot.Bytes(), 9525 } 9526 } 9527 9528 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9529 t, err = decoder.GetElement("Error") 9530 if err != nil { 9531 var snapshot bytes.Buffer 9532 io.Copy(&snapshot, ringBuffer) 9533 return &smithy.DeserializationError{ 9534 Err: fmt.Errorf("failed to decode response body, %w", err), 9535 Snapshot: snapshot.Bytes(), 9536 } 9537 } 9538 9539 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9540 err = awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(&output, decoder) 9541 if err != nil { 9542 var snapshot bytes.Buffer 9543 io.Copy(&snapshot, ringBuffer) 9544 return &smithy.DeserializationError{ 9545 Err: fmt.Errorf("failed to decode response body, %w", err), 9546 Snapshot: snapshot.Bytes(), 9547 } 9548 } 9549 9550 return output 9551} 9552 9553func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9554 output := &types.SourceNotFoundFault{} 9555 var buff [1024]byte 9556 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9557 body := io.TeeReader(errorBody, ringBuffer) 9558 rootDecoder := xml.NewDecoder(body) 9559 t, err := smithyxml.FetchRootElement(rootDecoder) 9560 if err == io.EOF { 9561 return output 9562 } 9563 if err != nil { 9564 var snapshot bytes.Buffer 9565 io.Copy(&snapshot, ringBuffer) 9566 return &smithy.DeserializationError{ 9567 Err: fmt.Errorf("failed to decode response body, %w", err), 9568 Snapshot: snapshot.Bytes(), 9569 } 9570 } 9571 9572 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9573 t, err = decoder.GetElement("Error") 9574 if err != nil { 9575 var snapshot bytes.Buffer 9576 io.Copy(&snapshot, ringBuffer) 9577 return &smithy.DeserializationError{ 9578 Err: fmt.Errorf("failed to decode response body, %w", err), 9579 Snapshot: snapshot.Bytes(), 9580 } 9581 } 9582 9583 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9584 err = awsAwsquery_deserializeDocumentSourceNotFoundFault(&output, decoder) 9585 if err != nil { 9586 var snapshot bytes.Buffer 9587 io.Copy(&snapshot, ringBuffer) 9588 return &smithy.DeserializationError{ 9589 Err: fmt.Errorf("failed to decode response body, %w", err), 9590 Snapshot: snapshot.Bytes(), 9591 } 9592 } 9593 9594 return output 9595} 9596 9597func awsAwsquery_deserializeErrorStorageQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9598 output := &types.StorageQuotaExceededFault{} 9599 var buff [1024]byte 9600 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9601 body := io.TeeReader(errorBody, ringBuffer) 9602 rootDecoder := xml.NewDecoder(body) 9603 t, err := smithyxml.FetchRootElement(rootDecoder) 9604 if err == io.EOF { 9605 return output 9606 } 9607 if err != nil { 9608 var snapshot bytes.Buffer 9609 io.Copy(&snapshot, ringBuffer) 9610 return &smithy.DeserializationError{ 9611 Err: fmt.Errorf("failed to decode response body, %w", err), 9612 Snapshot: snapshot.Bytes(), 9613 } 9614 } 9615 9616 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9617 t, err = decoder.GetElement("Error") 9618 if err != nil { 9619 var snapshot bytes.Buffer 9620 io.Copy(&snapshot, ringBuffer) 9621 return &smithy.DeserializationError{ 9622 Err: fmt.Errorf("failed to decode response body, %w", err), 9623 Snapshot: snapshot.Bytes(), 9624 } 9625 } 9626 9627 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9628 err = awsAwsquery_deserializeDocumentStorageQuotaExceededFault(&output, decoder) 9629 if err != nil { 9630 var snapshot bytes.Buffer 9631 io.Copy(&snapshot, ringBuffer) 9632 return &smithy.DeserializationError{ 9633 Err: fmt.Errorf("failed to decode response body, %w", err), 9634 Snapshot: snapshot.Bytes(), 9635 } 9636 } 9637 9638 return output 9639} 9640 9641func awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9642 output := &types.StorageTypeNotSupportedFault{} 9643 var buff [1024]byte 9644 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9645 body := io.TeeReader(errorBody, ringBuffer) 9646 rootDecoder := xml.NewDecoder(body) 9647 t, err := smithyxml.FetchRootElement(rootDecoder) 9648 if err == io.EOF { 9649 return output 9650 } 9651 if err != nil { 9652 var snapshot bytes.Buffer 9653 io.Copy(&snapshot, ringBuffer) 9654 return &smithy.DeserializationError{ 9655 Err: fmt.Errorf("failed to decode response body, %w", err), 9656 Snapshot: snapshot.Bytes(), 9657 } 9658 } 9659 9660 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9661 t, err = decoder.GetElement("Error") 9662 if err != nil { 9663 var snapshot bytes.Buffer 9664 io.Copy(&snapshot, ringBuffer) 9665 return &smithy.DeserializationError{ 9666 Err: fmt.Errorf("failed to decode response body, %w", err), 9667 Snapshot: snapshot.Bytes(), 9668 } 9669 } 9670 9671 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9672 err = awsAwsquery_deserializeDocumentStorageTypeNotSupportedFault(&output, decoder) 9673 if err != nil { 9674 var snapshot bytes.Buffer 9675 io.Copy(&snapshot, ringBuffer) 9676 return &smithy.DeserializationError{ 9677 Err: fmt.Errorf("failed to decode response body, %w", err), 9678 Snapshot: snapshot.Bytes(), 9679 } 9680 } 9681 9682 return output 9683} 9684 9685func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9686 output := &types.SubnetAlreadyInUse{} 9687 var buff [1024]byte 9688 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9689 body := io.TeeReader(errorBody, ringBuffer) 9690 rootDecoder := xml.NewDecoder(body) 9691 t, err := smithyxml.FetchRootElement(rootDecoder) 9692 if err == io.EOF { 9693 return output 9694 } 9695 if err != nil { 9696 var snapshot bytes.Buffer 9697 io.Copy(&snapshot, ringBuffer) 9698 return &smithy.DeserializationError{ 9699 Err: fmt.Errorf("failed to decode response body, %w", err), 9700 Snapshot: snapshot.Bytes(), 9701 } 9702 } 9703 9704 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9705 t, err = decoder.GetElement("Error") 9706 if err != nil { 9707 var snapshot bytes.Buffer 9708 io.Copy(&snapshot, ringBuffer) 9709 return &smithy.DeserializationError{ 9710 Err: fmt.Errorf("failed to decode response body, %w", err), 9711 Snapshot: snapshot.Bytes(), 9712 } 9713 } 9714 9715 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9716 err = awsAwsquery_deserializeDocumentSubnetAlreadyInUse(&output, decoder) 9717 if err != nil { 9718 var snapshot bytes.Buffer 9719 io.Copy(&snapshot, ringBuffer) 9720 return &smithy.DeserializationError{ 9721 Err: fmt.Errorf("failed to decode response body, %w", err), 9722 Snapshot: snapshot.Bytes(), 9723 } 9724 } 9725 9726 return output 9727} 9728 9729func awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9730 output := &types.SubscriptionAlreadyExistFault{} 9731 var buff [1024]byte 9732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9733 body := io.TeeReader(errorBody, ringBuffer) 9734 rootDecoder := xml.NewDecoder(body) 9735 t, err := smithyxml.FetchRootElement(rootDecoder) 9736 if err == io.EOF { 9737 return output 9738 } 9739 if err != nil { 9740 var snapshot bytes.Buffer 9741 io.Copy(&snapshot, ringBuffer) 9742 return &smithy.DeserializationError{ 9743 Err: fmt.Errorf("failed to decode response body, %w", err), 9744 Snapshot: snapshot.Bytes(), 9745 } 9746 } 9747 9748 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9749 t, err = decoder.GetElement("Error") 9750 if err != nil { 9751 var snapshot bytes.Buffer 9752 io.Copy(&snapshot, ringBuffer) 9753 return &smithy.DeserializationError{ 9754 Err: fmt.Errorf("failed to decode response body, %w", err), 9755 Snapshot: snapshot.Bytes(), 9756 } 9757 } 9758 9759 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9760 err = awsAwsquery_deserializeDocumentSubscriptionAlreadyExistFault(&output, decoder) 9761 if err != nil { 9762 var snapshot bytes.Buffer 9763 io.Copy(&snapshot, ringBuffer) 9764 return &smithy.DeserializationError{ 9765 Err: fmt.Errorf("failed to decode response body, %w", err), 9766 Snapshot: snapshot.Bytes(), 9767 } 9768 } 9769 9770 return output 9771} 9772 9773func awsAwsquery_deserializeErrorSubscriptionCategoryNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9774 output := &types.SubscriptionCategoryNotFoundFault{} 9775 var buff [1024]byte 9776 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9777 body := io.TeeReader(errorBody, ringBuffer) 9778 rootDecoder := xml.NewDecoder(body) 9779 t, err := smithyxml.FetchRootElement(rootDecoder) 9780 if err == io.EOF { 9781 return output 9782 } 9783 if err != nil { 9784 var snapshot bytes.Buffer 9785 io.Copy(&snapshot, ringBuffer) 9786 return &smithy.DeserializationError{ 9787 Err: fmt.Errorf("failed to decode response body, %w", err), 9788 Snapshot: snapshot.Bytes(), 9789 } 9790 } 9791 9792 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9793 t, err = decoder.GetElement("Error") 9794 if err != nil { 9795 var snapshot bytes.Buffer 9796 io.Copy(&snapshot, ringBuffer) 9797 return &smithy.DeserializationError{ 9798 Err: fmt.Errorf("failed to decode response body, %w", err), 9799 Snapshot: snapshot.Bytes(), 9800 } 9801 } 9802 9803 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9804 err = awsAwsquery_deserializeDocumentSubscriptionCategoryNotFoundFault(&output, decoder) 9805 if err != nil { 9806 var snapshot bytes.Buffer 9807 io.Copy(&snapshot, ringBuffer) 9808 return &smithy.DeserializationError{ 9809 Err: fmt.Errorf("failed to decode response body, %w", err), 9810 Snapshot: snapshot.Bytes(), 9811 } 9812 } 9813 9814 return output 9815} 9816 9817func awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9818 output := &types.SubscriptionNotFoundFault{} 9819 var buff [1024]byte 9820 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9821 body := io.TeeReader(errorBody, ringBuffer) 9822 rootDecoder := xml.NewDecoder(body) 9823 t, err := smithyxml.FetchRootElement(rootDecoder) 9824 if err == io.EOF { 9825 return output 9826 } 9827 if err != nil { 9828 var snapshot bytes.Buffer 9829 io.Copy(&snapshot, ringBuffer) 9830 return &smithy.DeserializationError{ 9831 Err: fmt.Errorf("failed to decode response body, %w", err), 9832 Snapshot: snapshot.Bytes(), 9833 } 9834 } 9835 9836 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9837 t, err = decoder.GetElement("Error") 9838 if err != nil { 9839 var snapshot bytes.Buffer 9840 io.Copy(&snapshot, ringBuffer) 9841 return &smithy.DeserializationError{ 9842 Err: fmt.Errorf("failed to decode response body, %w", err), 9843 Snapshot: snapshot.Bytes(), 9844 } 9845 } 9846 9847 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9848 err = awsAwsquery_deserializeDocumentSubscriptionNotFoundFault(&output, decoder) 9849 if err != nil { 9850 var snapshot bytes.Buffer 9851 io.Copy(&snapshot, ringBuffer) 9852 return &smithy.DeserializationError{ 9853 Err: fmt.Errorf("failed to decode response body, %w", err), 9854 Snapshot: snapshot.Bytes(), 9855 } 9856 } 9857 9858 return output 9859} 9860 9861func awsAwsquery_deserializeDocumentAttributeValueList(v *[]string, decoder smithyxml.NodeDecoder) error { 9862 if v == nil { 9863 return fmt.Errorf("unexpected nil of type %T", v) 9864 } 9865 var sv []string 9866 if *v == nil { 9867 sv = make([]string, 0) 9868 } else { 9869 sv = *v 9870 } 9871 9872 originalDecoder := decoder 9873 for { 9874 t, done, err := decoder.Token() 9875 if err != nil { 9876 return err 9877 } 9878 if done { 9879 break 9880 } 9881 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9882 decoder = memberDecoder 9883 switch { 9884 case strings.EqualFold("AttributeValue", t.Name.Local): 9885 var col string 9886 val, err := decoder.Value() 9887 if err != nil { 9888 return err 9889 } 9890 if val == nil { 9891 break 9892 } 9893 { 9894 xtv := string(val) 9895 col = xtv 9896 } 9897 sv = append(sv, col) 9898 9899 default: 9900 err = decoder.Decoder.Skip() 9901 if err != nil { 9902 return err 9903 } 9904 9905 } 9906 decoder = originalDecoder 9907 } 9908 *v = sv 9909 return nil 9910} 9911 9912func awsAwsquery_deserializeDocumentAttributeValueListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 9913 var sv []string 9914 if *v == nil { 9915 sv = make([]string, 0) 9916 } else { 9917 sv = *v 9918 } 9919 9920 switch { 9921 default: 9922 var mv string 9923 t := decoder.StartEl 9924 _ = t 9925 val, err := decoder.Value() 9926 if err != nil { 9927 return err 9928 } 9929 if val == nil { 9930 break 9931 } 9932 { 9933 xtv := string(val) 9934 mv = xtv 9935 } 9936 sv = append(sv, mv) 9937 } 9938 *v = sv 9939 return nil 9940} 9941func awsAwsquery_deserializeDocumentAuthorizationNotFoundFault(v **types.AuthorizationNotFoundFault, decoder smithyxml.NodeDecoder) error { 9942 if v == nil { 9943 return fmt.Errorf("unexpected nil of type %T", v) 9944 } 9945 var sv *types.AuthorizationNotFoundFault 9946 if *v == nil { 9947 sv = &types.AuthorizationNotFoundFault{} 9948 } else { 9949 sv = *v 9950 } 9951 9952 for { 9953 t, done, err := decoder.Token() 9954 if err != nil { 9955 return err 9956 } 9957 if done { 9958 break 9959 } 9960 originalDecoder := decoder 9961 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9962 switch { 9963 case strings.EqualFold("message", t.Name.Local): 9964 val, err := decoder.Value() 9965 if err != nil { 9966 return err 9967 } 9968 if val == nil { 9969 break 9970 } 9971 { 9972 xtv := string(val) 9973 sv.Message = ptr.String(xtv) 9974 } 9975 9976 default: 9977 // Do nothing and ignore the unexpected tag element 9978 err = decoder.Decoder.Skip() 9979 if err != nil { 9980 return err 9981 } 9982 9983 } 9984 decoder = originalDecoder 9985 } 9986 *v = sv 9987 return nil 9988} 9989 9990func awsAwsquery_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, decoder smithyxml.NodeDecoder) error { 9991 if v == nil { 9992 return fmt.Errorf("unexpected nil of type %T", v) 9993 } 9994 var sv *types.AvailabilityZone 9995 if *v == nil { 9996 sv = &types.AvailabilityZone{} 9997 } else { 9998 sv = *v 9999 } 10000 10001 for { 10002 t, done, err := decoder.Token() 10003 if err != nil { 10004 return err 10005 } 10006 if done { 10007 break 10008 } 10009 originalDecoder := decoder 10010 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10011 switch { 10012 case strings.EqualFold("Name", t.Name.Local): 10013 val, err := decoder.Value() 10014 if err != nil { 10015 return err 10016 } 10017 if val == nil { 10018 break 10019 } 10020 { 10021 xtv := string(val) 10022 sv.Name = ptr.String(xtv) 10023 } 10024 10025 default: 10026 // Do nothing and ignore the unexpected tag element 10027 err = decoder.Decoder.Skip() 10028 if err != nil { 10029 return err 10030 } 10031 10032 } 10033 decoder = originalDecoder 10034 } 10035 *v = sv 10036 return nil 10037} 10038 10039func awsAwsquery_deserializeDocumentAvailabilityZoneList(v *[]types.AvailabilityZone, decoder smithyxml.NodeDecoder) error { 10040 if v == nil { 10041 return fmt.Errorf("unexpected nil of type %T", v) 10042 } 10043 var sv []types.AvailabilityZone 10044 if *v == nil { 10045 sv = make([]types.AvailabilityZone, 0) 10046 } else { 10047 sv = *v 10048 } 10049 10050 originalDecoder := decoder 10051 for { 10052 t, done, err := decoder.Token() 10053 if err != nil { 10054 return err 10055 } 10056 if done { 10057 break 10058 } 10059 switch { 10060 case strings.EqualFold("AvailabilityZone", t.Name.Local): 10061 var col types.AvailabilityZone 10062 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10063 destAddr := &col 10064 if err := awsAwsquery_deserializeDocumentAvailabilityZone(&destAddr, nodeDecoder); err != nil { 10065 return err 10066 } 10067 col = *destAddr 10068 sv = append(sv, col) 10069 10070 default: 10071 err = decoder.Decoder.Skip() 10072 if err != nil { 10073 return err 10074 } 10075 10076 } 10077 decoder = originalDecoder 10078 } 10079 *v = sv 10080 return nil 10081} 10082 10083func awsAwsquery_deserializeDocumentAvailabilityZoneListUnwrapped(v *[]types.AvailabilityZone, decoder smithyxml.NodeDecoder) error { 10084 var sv []types.AvailabilityZone 10085 if *v == nil { 10086 sv = make([]types.AvailabilityZone, 0) 10087 } else { 10088 sv = *v 10089 } 10090 10091 switch { 10092 default: 10093 var mv types.AvailabilityZone 10094 t := decoder.StartEl 10095 _ = t 10096 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10097 destAddr := &mv 10098 if err := awsAwsquery_deserializeDocumentAvailabilityZone(&destAddr, nodeDecoder); err != nil { 10099 return err 10100 } 10101 mv = *destAddr 10102 sv = append(sv, mv) 10103 } 10104 *v = sv 10105 return nil 10106} 10107func awsAwsquery_deserializeDocumentAvailabilityZones(v *[]string, decoder smithyxml.NodeDecoder) error { 10108 if v == nil { 10109 return fmt.Errorf("unexpected nil of type %T", v) 10110 } 10111 var sv []string 10112 if *v == nil { 10113 sv = make([]string, 0) 10114 } else { 10115 sv = *v 10116 } 10117 10118 originalDecoder := decoder 10119 for { 10120 t, done, err := decoder.Token() 10121 if err != nil { 10122 return err 10123 } 10124 if done { 10125 break 10126 } 10127 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10128 decoder = memberDecoder 10129 switch { 10130 case strings.EqualFold("AvailabilityZone", t.Name.Local): 10131 var col string 10132 val, err := decoder.Value() 10133 if err != nil { 10134 return err 10135 } 10136 if val == nil { 10137 break 10138 } 10139 { 10140 xtv := string(val) 10141 col = xtv 10142 } 10143 sv = append(sv, col) 10144 10145 default: 10146 err = decoder.Decoder.Skip() 10147 if err != nil { 10148 return err 10149 } 10150 10151 } 10152 decoder = originalDecoder 10153 } 10154 *v = sv 10155 return nil 10156} 10157 10158func awsAwsquery_deserializeDocumentAvailabilityZonesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 10159 var sv []string 10160 if *v == nil { 10161 sv = make([]string, 0) 10162 } else { 10163 sv = *v 10164 } 10165 10166 switch { 10167 default: 10168 var mv string 10169 t := decoder.StartEl 10170 _ = t 10171 val, err := decoder.Value() 10172 if err != nil { 10173 return err 10174 } 10175 if val == nil { 10176 break 10177 } 10178 { 10179 xtv := string(val) 10180 mv = xtv 10181 } 10182 sv = append(sv, mv) 10183 } 10184 *v = sv 10185 return nil 10186} 10187func awsAwsquery_deserializeDocumentCertificateNotFoundFault(v **types.CertificateNotFoundFault, decoder smithyxml.NodeDecoder) error { 10188 if v == nil { 10189 return fmt.Errorf("unexpected nil of type %T", v) 10190 } 10191 var sv *types.CertificateNotFoundFault 10192 if *v == nil { 10193 sv = &types.CertificateNotFoundFault{} 10194 } else { 10195 sv = *v 10196 } 10197 10198 for { 10199 t, done, err := decoder.Token() 10200 if err != nil { 10201 return err 10202 } 10203 if done { 10204 break 10205 } 10206 originalDecoder := decoder 10207 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10208 switch { 10209 case strings.EqualFold("message", t.Name.Local): 10210 val, err := decoder.Value() 10211 if err != nil { 10212 return err 10213 } 10214 if val == nil { 10215 break 10216 } 10217 { 10218 xtv := string(val) 10219 sv.Message = ptr.String(xtv) 10220 } 10221 10222 default: 10223 // Do nothing and ignore the unexpected tag element 10224 err = decoder.Decoder.Skip() 10225 if err != nil { 10226 return err 10227 } 10228 10229 } 10230 decoder = originalDecoder 10231 } 10232 *v = sv 10233 return nil 10234} 10235 10236func awsAwsquery_deserializeDocumentCharacterSet(v **types.CharacterSet, decoder smithyxml.NodeDecoder) error { 10237 if v == nil { 10238 return fmt.Errorf("unexpected nil of type %T", v) 10239 } 10240 var sv *types.CharacterSet 10241 if *v == nil { 10242 sv = &types.CharacterSet{} 10243 } else { 10244 sv = *v 10245 } 10246 10247 for { 10248 t, done, err := decoder.Token() 10249 if err != nil { 10250 return err 10251 } 10252 if done { 10253 break 10254 } 10255 originalDecoder := decoder 10256 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10257 switch { 10258 case strings.EqualFold("CharacterSetDescription", t.Name.Local): 10259 val, err := decoder.Value() 10260 if err != nil { 10261 return err 10262 } 10263 if val == nil { 10264 break 10265 } 10266 { 10267 xtv := string(val) 10268 sv.CharacterSetDescription = ptr.String(xtv) 10269 } 10270 10271 case strings.EqualFold("CharacterSetName", t.Name.Local): 10272 val, err := decoder.Value() 10273 if err != nil { 10274 return err 10275 } 10276 if val == nil { 10277 break 10278 } 10279 { 10280 xtv := string(val) 10281 sv.CharacterSetName = ptr.String(xtv) 10282 } 10283 10284 default: 10285 // Do nothing and ignore the unexpected tag element 10286 err = decoder.Decoder.Skip() 10287 if err != nil { 10288 return err 10289 } 10290 10291 } 10292 decoder = originalDecoder 10293 } 10294 *v = sv 10295 return nil 10296} 10297 10298func awsAwsquery_deserializeDocumentDBCluster(v **types.DBCluster, decoder smithyxml.NodeDecoder) error { 10299 if v == nil { 10300 return fmt.Errorf("unexpected nil of type %T", v) 10301 } 10302 var sv *types.DBCluster 10303 if *v == nil { 10304 sv = &types.DBCluster{} 10305 } else { 10306 sv = *v 10307 } 10308 10309 for { 10310 t, done, err := decoder.Token() 10311 if err != nil { 10312 return err 10313 } 10314 if done { 10315 break 10316 } 10317 originalDecoder := decoder 10318 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10319 switch { 10320 case strings.EqualFold("AllocatedStorage", t.Name.Local): 10321 val, err := decoder.Value() 10322 if err != nil { 10323 return err 10324 } 10325 if val == nil { 10326 break 10327 } 10328 { 10329 xtv := string(val) 10330 i64, err := strconv.ParseInt(xtv, 10, 64) 10331 if err != nil { 10332 return err 10333 } 10334 sv.AllocatedStorage = ptr.Int32(int32(i64)) 10335 } 10336 10337 case strings.EqualFold("AssociatedRoles", t.Name.Local): 10338 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10339 if err := awsAwsquery_deserializeDocumentDBClusterRoles(&sv.AssociatedRoles, nodeDecoder); err != nil { 10340 return err 10341 } 10342 10343 case strings.EqualFold("AutomaticRestartTime", t.Name.Local): 10344 val, err := decoder.Value() 10345 if err != nil { 10346 return err 10347 } 10348 if val == nil { 10349 break 10350 } 10351 { 10352 xtv := string(val) 10353 t, err := smithytime.ParseDateTime(xtv) 10354 if err != nil { 10355 return err 10356 } 10357 sv.AutomaticRestartTime = ptr.Time(t) 10358 } 10359 10360 case strings.EqualFold("AvailabilityZones", t.Name.Local): 10361 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10362 if err := awsAwsquery_deserializeDocumentAvailabilityZones(&sv.AvailabilityZones, nodeDecoder); err != nil { 10363 return err 10364 } 10365 10366 case strings.EqualFold("BackupRetentionPeriod", t.Name.Local): 10367 val, err := decoder.Value() 10368 if err != nil { 10369 return err 10370 } 10371 if val == nil { 10372 break 10373 } 10374 { 10375 xtv := string(val) 10376 i64, err := strconv.ParseInt(xtv, 10, 64) 10377 if err != nil { 10378 return err 10379 } 10380 sv.BackupRetentionPeriod = ptr.Int32(int32(i64)) 10381 } 10382 10383 case strings.EqualFold("CharacterSetName", t.Name.Local): 10384 val, err := decoder.Value() 10385 if err != nil { 10386 return err 10387 } 10388 if val == nil { 10389 break 10390 } 10391 { 10392 xtv := string(val) 10393 sv.CharacterSetName = ptr.String(xtv) 10394 } 10395 10396 case strings.EqualFold("CloneGroupId", t.Name.Local): 10397 val, err := decoder.Value() 10398 if err != nil { 10399 return err 10400 } 10401 if val == nil { 10402 break 10403 } 10404 { 10405 xtv := string(val) 10406 sv.CloneGroupId = ptr.String(xtv) 10407 } 10408 10409 case strings.EqualFold("ClusterCreateTime", t.Name.Local): 10410 val, err := decoder.Value() 10411 if err != nil { 10412 return err 10413 } 10414 if val == nil { 10415 break 10416 } 10417 { 10418 xtv := string(val) 10419 t, err := smithytime.ParseDateTime(xtv) 10420 if err != nil { 10421 return err 10422 } 10423 sv.ClusterCreateTime = ptr.Time(t) 10424 } 10425 10426 case strings.EqualFold("CopyTagsToSnapshot", t.Name.Local): 10427 val, err := decoder.Value() 10428 if err != nil { 10429 return err 10430 } 10431 if val == nil { 10432 break 10433 } 10434 { 10435 xtv, err := strconv.ParseBool(string(val)) 10436 if err != nil { 10437 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 10438 } 10439 sv.CopyTagsToSnapshot = ptr.Bool(xtv) 10440 } 10441 10442 case strings.EqualFold("CrossAccountClone", t.Name.Local): 10443 val, err := decoder.Value() 10444 if err != nil { 10445 return err 10446 } 10447 if val == nil { 10448 break 10449 } 10450 { 10451 xtv, err := strconv.ParseBool(string(val)) 10452 if err != nil { 10453 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 10454 } 10455 sv.CrossAccountClone = ptr.Bool(xtv) 10456 } 10457 10458 case strings.EqualFold("DatabaseName", t.Name.Local): 10459 val, err := decoder.Value() 10460 if err != nil { 10461 return err 10462 } 10463 if val == nil { 10464 break 10465 } 10466 { 10467 xtv := string(val) 10468 sv.DatabaseName = ptr.String(xtv) 10469 } 10470 10471 case strings.EqualFold("DBClusterArn", t.Name.Local): 10472 val, err := decoder.Value() 10473 if err != nil { 10474 return err 10475 } 10476 if val == nil { 10477 break 10478 } 10479 { 10480 xtv := string(val) 10481 sv.DBClusterArn = ptr.String(xtv) 10482 } 10483 10484 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 10485 val, err := decoder.Value() 10486 if err != nil { 10487 return err 10488 } 10489 if val == nil { 10490 break 10491 } 10492 { 10493 xtv := string(val) 10494 sv.DBClusterIdentifier = ptr.String(xtv) 10495 } 10496 10497 case strings.EqualFold("DBClusterMembers", t.Name.Local): 10498 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10499 if err := awsAwsquery_deserializeDocumentDBClusterMemberList(&sv.DBClusterMembers, nodeDecoder); err != nil { 10500 return err 10501 } 10502 10503 case strings.EqualFold("DBClusterOptionGroupMemberships", t.Name.Local): 10504 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10505 if err := awsAwsquery_deserializeDocumentDBClusterOptionGroupMemberships(&sv.DBClusterOptionGroupMemberships, nodeDecoder); err != nil { 10506 return err 10507 } 10508 10509 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 10510 val, err := decoder.Value() 10511 if err != nil { 10512 return err 10513 } 10514 if val == nil { 10515 break 10516 } 10517 { 10518 xtv := string(val) 10519 sv.DBClusterParameterGroup = ptr.String(xtv) 10520 } 10521 10522 case strings.EqualFold("DbClusterResourceId", t.Name.Local): 10523 val, err := decoder.Value() 10524 if err != nil { 10525 return err 10526 } 10527 if val == nil { 10528 break 10529 } 10530 { 10531 xtv := string(val) 10532 sv.DbClusterResourceId = ptr.String(xtv) 10533 } 10534 10535 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 10536 val, err := decoder.Value() 10537 if err != nil { 10538 return err 10539 } 10540 if val == nil { 10541 break 10542 } 10543 { 10544 xtv := string(val) 10545 sv.DBSubnetGroup = ptr.String(xtv) 10546 } 10547 10548 case strings.EqualFold("DeletionProtection", t.Name.Local): 10549 val, err := decoder.Value() 10550 if err != nil { 10551 return err 10552 } 10553 if val == nil { 10554 break 10555 } 10556 { 10557 xtv, err := strconv.ParseBool(string(val)) 10558 if err != nil { 10559 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 10560 } 10561 sv.DeletionProtection = ptr.Bool(xtv) 10562 } 10563 10564 case strings.EqualFold("EarliestRestorableTime", t.Name.Local): 10565 val, err := decoder.Value() 10566 if err != nil { 10567 return err 10568 } 10569 if val == nil { 10570 break 10571 } 10572 { 10573 xtv := string(val) 10574 t, err := smithytime.ParseDateTime(xtv) 10575 if err != nil { 10576 return err 10577 } 10578 sv.EarliestRestorableTime = ptr.Time(t) 10579 } 10580 10581 case strings.EqualFold("EnabledCloudwatchLogsExports", t.Name.Local): 10582 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10583 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.EnabledCloudwatchLogsExports, nodeDecoder); err != nil { 10584 return err 10585 } 10586 10587 case strings.EqualFold("Endpoint", t.Name.Local): 10588 val, err := decoder.Value() 10589 if err != nil { 10590 return err 10591 } 10592 if val == nil { 10593 break 10594 } 10595 { 10596 xtv := string(val) 10597 sv.Endpoint = ptr.String(xtv) 10598 } 10599 10600 case strings.EqualFold("Engine", t.Name.Local): 10601 val, err := decoder.Value() 10602 if err != nil { 10603 return err 10604 } 10605 if val == nil { 10606 break 10607 } 10608 { 10609 xtv := string(val) 10610 sv.Engine = ptr.String(xtv) 10611 } 10612 10613 case strings.EqualFold("EngineVersion", t.Name.Local): 10614 val, err := decoder.Value() 10615 if err != nil { 10616 return err 10617 } 10618 if val == nil { 10619 break 10620 } 10621 { 10622 xtv := string(val) 10623 sv.EngineVersion = ptr.String(xtv) 10624 } 10625 10626 case strings.EqualFold("HostedZoneId", t.Name.Local): 10627 val, err := decoder.Value() 10628 if err != nil { 10629 return err 10630 } 10631 if val == nil { 10632 break 10633 } 10634 { 10635 xtv := string(val) 10636 sv.HostedZoneId = ptr.String(xtv) 10637 } 10638 10639 case strings.EqualFold("IAMDatabaseAuthenticationEnabled", t.Name.Local): 10640 val, err := decoder.Value() 10641 if err != nil { 10642 return err 10643 } 10644 if val == nil { 10645 break 10646 } 10647 { 10648 xtv, err := strconv.ParseBool(string(val)) 10649 if err != nil { 10650 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 10651 } 10652 sv.IAMDatabaseAuthenticationEnabled = xtv 10653 } 10654 10655 case strings.EqualFold("KmsKeyId", t.Name.Local): 10656 val, err := decoder.Value() 10657 if err != nil { 10658 return err 10659 } 10660 if val == nil { 10661 break 10662 } 10663 { 10664 xtv := string(val) 10665 sv.KmsKeyId = ptr.String(xtv) 10666 } 10667 10668 case strings.EqualFold("LatestRestorableTime", t.Name.Local): 10669 val, err := decoder.Value() 10670 if err != nil { 10671 return err 10672 } 10673 if val == nil { 10674 break 10675 } 10676 { 10677 xtv := string(val) 10678 t, err := smithytime.ParseDateTime(xtv) 10679 if err != nil { 10680 return err 10681 } 10682 sv.LatestRestorableTime = ptr.Time(t) 10683 } 10684 10685 case strings.EqualFold("MasterUsername", t.Name.Local): 10686 val, err := decoder.Value() 10687 if err != nil { 10688 return err 10689 } 10690 if val == nil { 10691 break 10692 } 10693 { 10694 xtv := string(val) 10695 sv.MasterUsername = ptr.String(xtv) 10696 } 10697 10698 case strings.EqualFold("MultiAZ", t.Name.Local): 10699 val, err := decoder.Value() 10700 if err != nil { 10701 return err 10702 } 10703 if val == nil { 10704 break 10705 } 10706 { 10707 xtv, err := strconv.ParseBool(string(val)) 10708 if err != nil { 10709 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 10710 } 10711 sv.MultiAZ = xtv 10712 } 10713 10714 case strings.EqualFold("PercentProgress", t.Name.Local): 10715 val, err := decoder.Value() 10716 if err != nil { 10717 return err 10718 } 10719 if val == nil { 10720 break 10721 } 10722 { 10723 xtv := string(val) 10724 sv.PercentProgress = ptr.String(xtv) 10725 } 10726 10727 case strings.EqualFold("Port", t.Name.Local): 10728 val, err := decoder.Value() 10729 if err != nil { 10730 return err 10731 } 10732 if val == nil { 10733 break 10734 } 10735 { 10736 xtv := string(val) 10737 i64, err := strconv.ParseInt(xtv, 10, 64) 10738 if err != nil { 10739 return err 10740 } 10741 sv.Port = ptr.Int32(int32(i64)) 10742 } 10743 10744 case strings.EqualFold("PreferredBackupWindow", t.Name.Local): 10745 val, err := decoder.Value() 10746 if err != nil { 10747 return err 10748 } 10749 if val == nil { 10750 break 10751 } 10752 { 10753 xtv := string(val) 10754 sv.PreferredBackupWindow = ptr.String(xtv) 10755 } 10756 10757 case strings.EqualFold("PreferredMaintenanceWindow", t.Name.Local): 10758 val, err := decoder.Value() 10759 if err != nil { 10760 return err 10761 } 10762 if val == nil { 10763 break 10764 } 10765 { 10766 xtv := string(val) 10767 sv.PreferredMaintenanceWindow = ptr.String(xtv) 10768 } 10769 10770 case strings.EqualFold("ReaderEndpoint", t.Name.Local): 10771 val, err := decoder.Value() 10772 if err != nil { 10773 return err 10774 } 10775 if val == nil { 10776 break 10777 } 10778 { 10779 xtv := string(val) 10780 sv.ReaderEndpoint = ptr.String(xtv) 10781 } 10782 10783 case strings.EqualFold("ReadReplicaIdentifiers", t.Name.Local): 10784 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10785 if err := awsAwsquery_deserializeDocumentReadReplicaIdentifierList(&sv.ReadReplicaIdentifiers, nodeDecoder); err != nil { 10786 return err 10787 } 10788 10789 case strings.EqualFold("ReplicationSourceIdentifier", t.Name.Local): 10790 val, err := decoder.Value() 10791 if err != nil { 10792 return err 10793 } 10794 if val == nil { 10795 break 10796 } 10797 { 10798 xtv := string(val) 10799 sv.ReplicationSourceIdentifier = ptr.String(xtv) 10800 } 10801 10802 case strings.EqualFold("Status", t.Name.Local): 10803 val, err := decoder.Value() 10804 if err != nil { 10805 return err 10806 } 10807 if val == nil { 10808 break 10809 } 10810 { 10811 xtv := string(val) 10812 sv.Status = ptr.String(xtv) 10813 } 10814 10815 case strings.EqualFold("StorageEncrypted", t.Name.Local): 10816 val, err := decoder.Value() 10817 if err != nil { 10818 return err 10819 } 10820 if val == nil { 10821 break 10822 } 10823 { 10824 xtv, err := strconv.ParseBool(string(val)) 10825 if err != nil { 10826 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 10827 } 10828 sv.StorageEncrypted = xtv 10829 } 10830 10831 case strings.EqualFold("VpcSecurityGroups", t.Name.Local): 10832 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10833 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipList(&sv.VpcSecurityGroups, nodeDecoder); err != nil { 10834 return err 10835 } 10836 10837 default: 10838 // Do nothing and ignore the unexpected tag element 10839 err = decoder.Decoder.Skip() 10840 if err != nil { 10841 return err 10842 } 10843 10844 } 10845 decoder = originalDecoder 10846 } 10847 *v = sv 10848 return nil 10849} 10850 10851func awsAwsquery_deserializeDocumentDBClusterAlreadyExistsFault(v **types.DBClusterAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 10852 if v == nil { 10853 return fmt.Errorf("unexpected nil of type %T", v) 10854 } 10855 var sv *types.DBClusterAlreadyExistsFault 10856 if *v == nil { 10857 sv = &types.DBClusterAlreadyExistsFault{} 10858 } else { 10859 sv = *v 10860 } 10861 10862 for { 10863 t, done, err := decoder.Token() 10864 if err != nil { 10865 return err 10866 } 10867 if done { 10868 break 10869 } 10870 originalDecoder := decoder 10871 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10872 switch { 10873 case strings.EqualFold("message", t.Name.Local): 10874 val, err := decoder.Value() 10875 if err != nil { 10876 return err 10877 } 10878 if val == nil { 10879 break 10880 } 10881 { 10882 xtv := string(val) 10883 sv.Message = ptr.String(xtv) 10884 } 10885 10886 default: 10887 // Do nothing and ignore the unexpected tag element 10888 err = decoder.Decoder.Skip() 10889 if err != nil { 10890 return err 10891 } 10892 10893 } 10894 decoder = originalDecoder 10895 } 10896 *v = sv 10897 return nil 10898} 10899 10900func awsAwsquery_deserializeDocumentDBClusterEndpoint(v **types.DBClusterEndpoint, decoder smithyxml.NodeDecoder) error { 10901 if v == nil { 10902 return fmt.Errorf("unexpected nil of type %T", v) 10903 } 10904 var sv *types.DBClusterEndpoint 10905 if *v == nil { 10906 sv = &types.DBClusterEndpoint{} 10907 } else { 10908 sv = *v 10909 } 10910 10911 for { 10912 t, done, err := decoder.Token() 10913 if err != nil { 10914 return err 10915 } 10916 if done { 10917 break 10918 } 10919 originalDecoder := decoder 10920 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10921 switch { 10922 case strings.EqualFold("CustomEndpointType", t.Name.Local): 10923 val, err := decoder.Value() 10924 if err != nil { 10925 return err 10926 } 10927 if val == nil { 10928 break 10929 } 10930 { 10931 xtv := string(val) 10932 sv.CustomEndpointType = ptr.String(xtv) 10933 } 10934 10935 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 10936 val, err := decoder.Value() 10937 if err != nil { 10938 return err 10939 } 10940 if val == nil { 10941 break 10942 } 10943 { 10944 xtv := string(val) 10945 sv.DBClusterEndpointArn = ptr.String(xtv) 10946 } 10947 10948 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 10949 val, err := decoder.Value() 10950 if err != nil { 10951 return err 10952 } 10953 if val == nil { 10954 break 10955 } 10956 { 10957 xtv := string(val) 10958 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 10959 } 10960 10961 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 10962 val, err := decoder.Value() 10963 if err != nil { 10964 return err 10965 } 10966 if val == nil { 10967 break 10968 } 10969 { 10970 xtv := string(val) 10971 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 10972 } 10973 10974 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 10975 val, err := decoder.Value() 10976 if err != nil { 10977 return err 10978 } 10979 if val == nil { 10980 break 10981 } 10982 { 10983 xtv := string(val) 10984 sv.DBClusterIdentifier = ptr.String(xtv) 10985 } 10986 10987 case strings.EqualFold("Endpoint", t.Name.Local): 10988 val, err := decoder.Value() 10989 if err != nil { 10990 return err 10991 } 10992 if val == nil { 10993 break 10994 } 10995 { 10996 xtv := string(val) 10997 sv.Endpoint = ptr.String(xtv) 10998 } 10999 11000 case strings.EqualFold("EndpointType", t.Name.Local): 11001 val, err := decoder.Value() 11002 if err != nil { 11003 return err 11004 } 11005 if val == nil { 11006 break 11007 } 11008 { 11009 xtv := string(val) 11010 sv.EndpointType = ptr.String(xtv) 11011 } 11012 11013 case strings.EqualFold("ExcludedMembers", t.Name.Local): 11014 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11015 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 11016 return err 11017 } 11018 11019 case strings.EqualFold("StaticMembers", t.Name.Local): 11020 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11021 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 11022 return err 11023 } 11024 11025 case strings.EqualFold("Status", t.Name.Local): 11026 val, err := decoder.Value() 11027 if err != nil { 11028 return err 11029 } 11030 if val == nil { 11031 break 11032 } 11033 { 11034 xtv := string(val) 11035 sv.Status = ptr.String(xtv) 11036 } 11037 11038 default: 11039 // Do nothing and ignore the unexpected tag element 11040 err = decoder.Decoder.Skip() 11041 if err != nil { 11042 return err 11043 } 11044 11045 } 11046 decoder = originalDecoder 11047 } 11048 *v = sv 11049 return nil 11050} 11051 11052func awsAwsquery_deserializeDocumentDBClusterEndpointAlreadyExistsFault(v **types.DBClusterEndpointAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 11053 if v == nil { 11054 return fmt.Errorf("unexpected nil of type %T", v) 11055 } 11056 var sv *types.DBClusterEndpointAlreadyExistsFault 11057 if *v == nil { 11058 sv = &types.DBClusterEndpointAlreadyExistsFault{} 11059 } else { 11060 sv = *v 11061 } 11062 11063 for { 11064 t, done, err := decoder.Token() 11065 if err != nil { 11066 return err 11067 } 11068 if done { 11069 break 11070 } 11071 originalDecoder := decoder 11072 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11073 switch { 11074 case strings.EqualFold("message", t.Name.Local): 11075 val, err := decoder.Value() 11076 if err != nil { 11077 return err 11078 } 11079 if val == nil { 11080 break 11081 } 11082 { 11083 xtv := string(val) 11084 sv.Message = ptr.String(xtv) 11085 } 11086 11087 default: 11088 // Do nothing and ignore the unexpected tag element 11089 err = decoder.Decoder.Skip() 11090 if err != nil { 11091 return err 11092 } 11093 11094 } 11095 decoder = originalDecoder 11096 } 11097 *v = sv 11098 return nil 11099} 11100 11101func awsAwsquery_deserializeDocumentDBClusterEndpointList(v *[]types.DBClusterEndpoint, decoder smithyxml.NodeDecoder) error { 11102 if v == nil { 11103 return fmt.Errorf("unexpected nil of type %T", v) 11104 } 11105 var sv []types.DBClusterEndpoint 11106 if *v == nil { 11107 sv = make([]types.DBClusterEndpoint, 0) 11108 } else { 11109 sv = *v 11110 } 11111 11112 originalDecoder := decoder 11113 for { 11114 t, done, err := decoder.Token() 11115 if err != nil { 11116 return err 11117 } 11118 if done { 11119 break 11120 } 11121 switch { 11122 case strings.EqualFold("DBClusterEndpointList", t.Name.Local): 11123 var col types.DBClusterEndpoint 11124 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11125 destAddr := &col 11126 if err := awsAwsquery_deserializeDocumentDBClusterEndpoint(&destAddr, nodeDecoder); err != nil { 11127 return err 11128 } 11129 col = *destAddr 11130 sv = append(sv, col) 11131 11132 default: 11133 err = decoder.Decoder.Skip() 11134 if err != nil { 11135 return err 11136 } 11137 11138 } 11139 decoder = originalDecoder 11140 } 11141 *v = sv 11142 return nil 11143} 11144 11145func awsAwsquery_deserializeDocumentDBClusterEndpointListUnwrapped(v *[]types.DBClusterEndpoint, decoder smithyxml.NodeDecoder) error { 11146 var sv []types.DBClusterEndpoint 11147 if *v == nil { 11148 sv = make([]types.DBClusterEndpoint, 0) 11149 } else { 11150 sv = *v 11151 } 11152 11153 switch { 11154 default: 11155 var mv types.DBClusterEndpoint 11156 t := decoder.StartEl 11157 _ = t 11158 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11159 destAddr := &mv 11160 if err := awsAwsquery_deserializeDocumentDBClusterEndpoint(&destAddr, nodeDecoder); err != nil { 11161 return err 11162 } 11163 mv = *destAddr 11164 sv = append(sv, mv) 11165 } 11166 *v = sv 11167 return nil 11168} 11169func awsAwsquery_deserializeDocumentDBClusterEndpointNotFoundFault(v **types.DBClusterEndpointNotFoundFault, decoder smithyxml.NodeDecoder) error { 11170 if v == nil { 11171 return fmt.Errorf("unexpected nil of type %T", v) 11172 } 11173 var sv *types.DBClusterEndpointNotFoundFault 11174 if *v == nil { 11175 sv = &types.DBClusterEndpointNotFoundFault{} 11176 } else { 11177 sv = *v 11178 } 11179 11180 for { 11181 t, done, err := decoder.Token() 11182 if err != nil { 11183 return err 11184 } 11185 if done { 11186 break 11187 } 11188 originalDecoder := decoder 11189 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11190 switch { 11191 case strings.EqualFold("message", t.Name.Local): 11192 val, err := decoder.Value() 11193 if err != nil { 11194 return err 11195 } 11196 if val == nil { 11197 break 11198 } 11199 { 11200 xtv := string(val) 11201 sv.Message = ptr.String(xtv) 11202 } 11203 11204 default: 11205 // Do nothing and ignore the unexpected tag element 11206 err = decoder.Decoder.Skip() 11207 if err != nil { 11208 return err 11209 } 11210 11211 } 11212 decoder = originalDecoder 11213 } 11214 *v = sv 11215 return nil 11216} 11217 11218func awsAwsquery_deserializeDocumentDBClusterEndpointQuotaExceededFault(v **types.DBClusterEndpointQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 11219 if v == nil { 11220 return fmt.Errorf("unexpected nil of type %T", v) 11221 } 11222 var sv *types.DBClusterEndpointQuotaExceededFault 11223 if *v == nil { 11224 sv = &types.DBClusterEndpointQuotaExceededFault{} 11225 } else { 11226 sv = *v 11227 } 11228 11229 for { 11230 t, done, err := decoder.Token() 11231 if err != nil { 11232 return err 11233 } 11234 if done { 11235 break 11236 } 11237 originalDecoder := decoder 11238 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11239 switch { 11240 case strings.EqualFold("message", t.Name.Local): 11241 val, err := decoder.Value() 11242 if err != nil { 11243 return err 11244 } 11245 if val == nil { 11246 break 11247 } 11248 { 11249 xtv := string(val) 11250 sv.Message = ptr.String(xtv) 11251 } 11252 11253 default: 11254 // Do nothing and ignore the unexpected tag element 11255 err = decoder.Decoder.Skip() 11256 if err != nil { 11257 return err 11258 } 11259 11260 } 11261 decoder = originalDecoder 11262 } 11263 *v = sv 11264 return nil 11265} 11266 11267func awsAwsquery_deserializeDocumentDBClusterList(v *[]types.DBCluster, decoder smithyxml.NodeDecoder) error { 11268 if v == nil { 11269 return fmt.Errorf("unexpected nil of type %T", v) 11270 } 11271 var sv []types.DBCluster 11272 if *v == nil { 11273 sv = make([]types.DBCluster, 0) 11274 } else { 11275 sv = *v 11276 } 11277 11278 originalDecoder := decoder 11279 for { 11280 t, done, err := decoder.Token() 11281 if err != nil { 11282 return err 11283 } 11284 if done { 11285 break 11286 } 11287 switch { 11288 case strings.EqualFold("DBCluster", t.Name.Local): 11289 var col types.DBCluster 11290 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11291 destAddr := &col 11292 if err := awsAwsquery_deserializeDocumentDBCluster(&destAddr, nodeDecoder); err != nil { 11293 return err 11294 } 11295 col = *destAddr 11296 sv = append(sv, col) 11297 11298 default: 11299 err = decoder.Decoder.Skip() 11300 if err != nil { 11301 return err 11302 } 11303 11304 } 11305 decoder = originalDecoder 11306 } 11307 *v = sv 11308 return nil 11309} 11310 11311func awsAwsquery_deserializeDocumentDBClusterListUnwrapped(v *[]types.DBCluster, decoder smithyxml.NodeDecoder) error { 11312 var sv []types.DBCluster 11313 if *v == nil { 11314 sv = make([]types.DBCluster, 0) 11315 } else { 11316 sv = *v 11317 } 11318 11319 switch { 11320 default: 11321 var mv types.DBCluster 11322 t := decoder.StartEl 11323 _ = t 11324 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11325 destAddr := &mv 11326 if err := awsAwsquery_deserializeDocumentDBCluster(&destAddr, nodeDecoder); err != nil { 11327 return err 11328 } 11329 mv = *destAddr 11330 sv = append(sv, mv) 11331 } 11332 *v = sv 11333 return nil 11334} 11335func awsAwsquery_deserializeDocumentDBClusterMember(v **types.DBClusterMember, decoder smithyxml.NodeDecoder) error { 11336 if v == nil { 11337 return fmt.Errorf("unexpected nil of type %T", v) 11338 } 11339 var sv *types.DBClusterMember 11340 if *v == nil { 11341 sv = &types.DBClusterMember{} 11342 } else { 11343 sv = *v 11344 } 11345 11346 for { 11347 t, done, err := decoder.Token() 11348 if err != nil { 11349 return err 11350 } 11351 if done { 11352 break 11353 } 11354 originalDecoder := decoder 11355 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11356 switch { 11357 case strings.EqualFold("DBClusterParameterGroupStatus", t.Name.Local): 11358 val, err := decoder.Value() 11359 if err != nil { 11360 return err 11361 } 11362 if val == nil { 11363 break 11364 } 11365 { 11366 xtv := string(val) 11367 sv.DBClusterParameterGroupStatus = ptr.String(xtv) 11368 } 11369 11370 case strings.EqualFold("DBInstanceIdentifier", t.Name.Local): 11371 val, err := decoder.Value() 11372 if err != nil { 11373 return err 11374 } 11375 if val == nil { 11376 break 11377 } 11378 { 11379 xtv := string(val) 11380 sv.DBInstanceIdentifier = ptr.String(xtv) 11381 } 11382 11383 case strings.EqualFold("IsClusterWriter", t.Name.Local): 11384 val, err := decoder.Value() 11385 if err != nil { 11386 return err 11387 } 11388 if val == nil { 11389 break 11390 } 11391 { 11392 xtv, err := strconv.ParseBool(string(val)) 11393 if err != nil { 11394 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 11395 } 11396 sv.IsClusterWriter = xtv 11397 } 11398 11399 case strings.EqualFold("PromotionTier", t.Name.Local): 11400 val, err := decoder.Value() 11401 if err != nil { 11402 return err 11403 } 11404 if val == nil { 11405 break 11406 } 11407 { 11408 xtv := string(val) 11409 i64, err := strconv.ParseInt(xtv, 10, 64) 11410 if err != nil { 11411 return err 11412 } 11413 sv.PromotionTier = ptr.Int32(int32(i64)) 11414 } 11415 11416 default: 11417 // Do nothing and ignore the unexpected tag element 11418 err = decoder.Decoder.Skip() 11419 if err != nil { 11420 return err 11421 } 11422 11423 } 11424 decoder = originalDecoder 11425 } 11426 *v = sv 11427 return nil 11428} 11429 11430func awsAwsquery_deserializeDocumentDBClusterMemberList(v *[]types.DBClusterMember, decoder smithyxml.NodeDecoder) error { 11431 if v == nil { 11432 return fmt.Errorf("unexpected nil of type %T", v) 11433 } 11434 var sv []types.DBClusterMember 11435 if *v == nil { 11436 sv = make([]types.DBClusterMember, 0) 11437 } else { 11438 sv = *v 11439 } 11440 11441 originalDecoder := decoder 11442 for { 11443 t, done, err := decoder.Token() 11444 if err != nil { 11445 return err 11446 } 11447 if done { 11448 break 11449 } 11450 switch { 11451 case strings.EqualFold("DBClusterMember", t.Name.Local): 11452 var col types.DBClusterMember 11453 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11454 destAddr := &col 11455 if err := awsAwsquery_deserializeDocumentDBClusterMember(&destAddr, nodeDecoder); err != nil { 11456 return err 11457 } 11458 col = *destAddr 11459 sv = append(sv, col) 11460 11461 default: 11462 err = decoder.Decoder.Skip() 11463 if err != nil { 11464 return err 11465 } 11466 11467 } 11468 decoder = originalDecoder 11469 } 11470 *v = sv 11471 return nil 11472} 11473 11474func awsAwsquery_deserializeDocumentDBClusterMemberListUnwrapped(v *[]types.DBClusterMember, decoder smithyxml.NodeDecoder) error { 11475 var sv []types.DBClusterMember 11476 if *v == nil { 11477 sv = make([]types.DBClusterMember, 0) 11478 } else { 11479 sv = *v 11480 } 11481 11482 switch { 11483 default: 11484 var mv types.DBClusterMember 11485 t := decoder.StartEl 11486 _ = t 11487 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11488 destAddr := &mv 11489 if err := awsAwsquery_deserializeDocumentDBClusterMember(&destAddr, nodeDecoder); err != nil { 11490 return err 11491 } 11492 mv = *destAddr 11493 sv = append(sv, mv) 11494 } 11495 *v = sv 11496 return nil 11497} 11498func awsAwsquery_deserializeDocumentDBClusterNotFoundFault(v **types.DBClusterNotFoundFault, decoder smithyxml.NodeDecoder) error { 11499 if v == nil { 11500 return fmt.Errorf("unexpected nil of type %T", v) 11501 } 11502 var sv *types.DBClusterNotFoundFault 11503 if *v == nil { 11504 sv = &types.DBClusterNotFoundFault{} 11505 } else { 11506 sv = *v 11507 } 11508 11509 for { 11510 t, done, err := decoder.Token() 11511 if err != nil { 11512 return err 11513 } 11514 if done { 11515 break 11516 } 11517 originalDecoder := decoder 11518 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11519 switch { 11520 case strings.EqualFold("message", t.Name.Local): 11521 val, err := decoder.Value() 11522 if err != nil { 11523 return err 11524 } 11525 if val == nil { 11526 break 11527 } 11528 { 11529 xtv := string(val) 11530 sv.Message = ptr.String(xtv) 11531 } 11532 11533 default: 11534 // Do nothing and ignore the unexpected tag element 11535 err = decoder.Decoder.Skip() 11536 if err != nil { 11537 return err 11538 } 11539 11540 } 11541 decoder = originalDecoder 11542 } 11543 *v = sv 11544 return nil 11545} 11546 11547func awsAwsquery_deserializeDocumentDBClusterOptionGroupMemberships(v *[]types.DBClusterOptionGroupStatus, decoder smithyxml.NodeDecoder) error { 11548 if v == nil { 11549 return fmt.Errorf("unexpected nil of type %T", v) 11550 } 11551 var sv []types.DBClusterOptionGroupStatus 11552 if *v == nil { 11553 sv = make([]types.DBClusterOptionGroupStatus, 0) 11554 } else { 11555 sv = *v 11556 } 11557 11558 originalDecoder := decoder 11559 for { 11560 t, done, err := decoder.Token() 11561 if err != nil { 11562 return err 11563 } 11564 if done { 11565 break 11566 } 11567 switch { 11568 case strings.EqualFold("DBClusterOptionGroup", t.Name.Local): 11569 var col types.DBClusterOptionGroupStatus 11570 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11571 destAddr := &col 11572 if err := awsAwsquery_deserializeDocumentDBClusterOptionGroupStatus(&destAddr, nodeDecoder); err != nil { 11573 return err 11574 } 11575 col = *destAddr 11576 sv = append(sv, col) 11577 11578 default: 11579 err = decoder.Decoder.Skip() 11580 if err != nil { 11581 return err 11582 } 11583 11584 } 11585 decoder = originalDecoder 11586 } 11587 *v = sv 11588 return nil 11589} 11590 11591func awsAwsquery_deserializeDocumentDBClusterOptionGroupMembershipsUnwrapped(v *[]types.DBClusterOptionGroupStatus, decoder smithyxml.NodeDecoder) error { 11592 var sv []types.DBClusterOptionGroupStatus 11593 if *v == nil { 11594 sv = make([]types.DBClusterOptionGroupStatus, 0) 11595 } else { 11596 sv = *v 11597 } 11598 11599 switch { 11600 default: 11601 var mv types.DBClusterOptionGroupStatus 11602 t := decoder.StartEl 11603 _ = t 11604 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11605 destAddr := &mv 11606 if err := awsAwsquery_deserializeDocumentDBClusterOptionGroupStatus(&destAddr, nodeDecoder); err != nil { 11607 return err 11608 } 11609 mv = *destAddr 11610 sv = append(sv, mv) 11611 } 11612 *v = sv 11613 return nil 11614} 11615func awsAwsquery_deserializeDocumentDBClusterOptionGroupStatus(v **types.DBClusterOptionGroupStatus, decoder smithyxml.NodeDecoder) error { 11616 if v == nil { 11617 return fmt.Errorf("unexpected nil of type %T", v) 11618 } 11619 var sv *types.DBClusterOptionGroupStatus 11620 if *v == nil { 11621 sv = &types.DBClusterOptionGroupStatus{} 11622 } else { 11623 sv = *v 11624 } 11625 11626 for { 11627 t, done, err := decoder.Token() 11628 if err != nil { 11629 return err 11630 } 11631 if done { 11632 break 11633 } 11634 originalDecoder := decoder 11635 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11636 switch { 11637 case strings.EqualFold("DBClusterOptionGroupName", t.Name.Local): 11638 val, err := decoder.Value() 11639 if err != nil { 11640 return err 11641 } 11642 if val == nil { 11643 break 11644 } 11645 { 11646 xtv := string(val) 11647 sv.DBClusterOptionGroupName = ptr.String(xtv) 11648 } 11649 11650 case strings.EqualFold("Status", t.Name.Local): 11651 val, err := decoder.Value() 11652 if err != nil { 11653 return err 11654 } 11655 if val == nil { 11656 break 11657 } 11658 { 11659 xtv := string(val) 11660 sv.Status = ptr.String(xtv) 11661 } 11662 11663 default: 11664 // Do nothing and ignore the unexpected tag element 11665 err = decoder.Decoder.Skip() 11666 if err != nil { 11667 return err 11668 } 11669 11670 } 11671 decoder = originalDecoder 11672 } 11673 *v = sv 11674 return nil 11675} 11676 11677func awsAwsquery_deserializeDocumentDBClusterParameterGroup(v **types.DBClusterParameterGroup, decoder smithyxml.NodeDecoder) error { 11678 if v == nil { 11679 return fmt.Errorf("unexpected nil of type %T", v) 11680 } 11681 var sv *types.DBClusterParameterGroup 11682 if *v == nil { 11683 sv = &types.DBClusterParameterGroup{} 11684 } else { 11685 sv = *v 11686 } 11687 11688 for { 11689 t, done, err := decoder.Token() 11690 if err != nil { 11691 return err 11692 } 11693 if done { 11694 break 11695 } 11696 originalDecoder := decoder 11697 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11698 switch { 11699 case strings.EqualFold("DBClusterParameterGroupArn", t.Name.Local): 11700 val, err := decoder.Value() 11701 if err != nil { 11702 return err 11703 } 11704 if val == nil { 11705 break 11706 } 11707 { 11708 xtv := string(val) 11709 sv.DBClusterParameterGroupArn = ptr.String(xtv) 11710 } 11711 11712 case strings.EqualFold("DBClusterParameterGroupName", t.Name.Local): 11713 val, err := decoder.Value() 11714 if err != nil { 11715 return err 11716 } 11717 if val == nil { 11718 break 11719 } 11720 { 11721 xtv := string(val) 11722 sv.DBClusterParameterGroupName = ptr.String(xtv) 11723 } 11724 11725 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 11726 val, err := decoder.Value() 11727 if err != nil { 11728 return err 11729 } 11730 if val == nil { 11731 break 11732 } 11733 { 11734 xtv := string(val) 11735 sv.DBParameterGroupFamily = ptr.String(xtv) 11736 } 11737 11738 case strings.EqualFold("Description", t.Name.Local): 11739 val, err := decoder.Value() 11740 if err != nil { 11741 return err 11742 } 11743 if val == nil { 11744 break 11745 } 11746 { 11747 xtv := string(val) 11748 sv.Description = ptr.String(xtv) 11749 } 11750 11751 default: 11752 // Do nothing and ignore the unexpected tag element 11753 err = decoder.Decoder.Skip() 11754 if err != nil { 11755 return err 11756 } 11757 11758 } 11759 decoder = originalDecoder 11760 } 11761 *v = sv 11762 return nil 11763} 11764 11765func awsAwsquery_deserializeDocumentDBClusterParameterGroupList(v *[]types.DBClusterParameterGroup, decoder smithyxml.NodeDecoder) error { 11766 if v == nil { 11767 return fmt.Errorf("unexpected nil of type %T", v) 11768 } 11769 var sv []types.DBClusterParameterGroup 11770 if *v == nil { 11771 sv = make([]types.DBClusterParameterGroup, 0) 11772 } else { 11773 sv = *v 11774 } 11775 11776 originalDecoder := decoder 11777 for { 11778 t, done, err := decoder.Token() 11779 if err != nil { 11780 return err 11781 } 11782 if done { 11783 break 11784 } 11785 switch { 11786 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 11787 var col types.DBClusterParameterGroup 11788 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11789 destAddr := &col 11790 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&destAddr, nodeDecoder); err != nil { 11791 return err 11792 } 11793 col = *destAddr 11794 sv = append(sv, col) 11795 11796 default: 11797 err = decoder.Decoder.Skip() 11798 if err != nil { 11799 return err 11800 } 11801 11802 } 11803 decoder = originalDecoder 11804 } 11805 *v = sv 11806 return nil 11807} 11808 11809func awsAwsquery_deserializeDocumentDBClusterParameterGroupListUnwrapped(v *[]types.DBClusterParameterGroup, decoder smithyxml.NodeDecoder) error { 11810 var sv []types.DBClusterParameterGroup 11811 if *v == nil { 11812 sv = make([]types.DBClusterParameterGroup, 0) 11813 } else { 11814 sv = *v 11815 } 11816 11817 switch { 11818 default: 11819 var mv types.DBClusterParameterGroup 11820 t := decoder.StartEl 11821 _ = t 11822 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11823 destAddr := &mv 11824 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&destAddr, nodeDecoder); err != nil { 11825 return err 11826 } 11827 mv = *destAddr 11828 sv = append(sv, mv) 11829 } 11830 *v = sv 11831 return nil 11832} 11833func awsAwsquery_deserializeDocumentDBClusterParameterGroupNotFoundFault(v **types.DBClusterParameterGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 11834 if v == nil { 11835 return fmt.Errorf("unexpected nil of type %T", v) 11836 } 11837 var sv *types.DBClusterParameterGroupNotFoundFault 11838 if *v == nil { 11839 sv = &types.DBClusterParameterGroupNotFoundFault{} 11840 } else { 11841 sv = *v 11842 } 11843 11844 for { 11845 t, done, err := decoder.Token() 11846 if err != nil { 11847 return err 11848 } 11849 if done { 11850 break 11851 } 11852 originalDecoder := decoder 11853 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11854 switch { 11855 case strings.EqualFold("message", t.Name.Local): 11856 val, err := decoder.Value() 11857 if err != nil { 11858 return err 11859 } 11860 if val == nil { 11861 break 11862 } 11863 { 11864 xtv := string(val) 11865 sv.Message = ptr.String(xtv) 11866 } 11867 11868 default: 11869 // Do nothing and ignore the unexpected tag element 11870 err = decoder.Decoder.Skip() 11871 if err != nil { 11872 return err 11873 } 11874 11875 } 11876 decoder = originalDecoder 11877 } 11878 *v = sv 11879 return nil 11880} 11881 11882func awsAwsquery_deserializeDocumentDBClusterQuotaExceededFault(v **types.DBClusterQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 11883 if v == nil { 11884 return fmt.Errorf("unexpected nil of type %T", v) 11885 } 11886 var sv *types.DBClusterQuotaExceededFault 11887 if *v == nil { 11888 sv = &types.DBClusterQuotaExceededFault{} 11889 } else { 11890 sv = *v 11891 } 11892 11893 for { 11894 t, done, err := decoder.Token() 11895 if err != nil { 11896 return err 11897 } 11898 if done { 11899 break 11900 } 11901 originalDecoder := decoder 11902 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11903 switch { 11904 case strings.EqualFold("message", t.Name.Local): 11905 val, err := decoder.Value() 11906 if err != nil { 11907 return err 11908 } 11909 if val == nil { 11910 break 11911 } 11912 { 11913 xtv := string(val) 11914 sv.Message = ptr.String(xtv) 11915 } 11916 11917 default: 11918 // Do nothing and ignore the unexpected tag element 11919 err = decoder.Decoder.Skip() 11920 if err != nil { 11921 return err 11922 } 11923 11924 } 11925 decoder = originalDecoder 11926 } 11927 *v = sv 11928 return nil 11929} 11930 11931func awsAwsquery_deserializeDocumentDBClusterRole(v **types.DBClusterRole, decoder smithyxml.NodeDecoder) error { 11932 if v == nil { 11933 return fmt.Errorf("unexpected nil of type %T", v) 11934 } 11935 var sv *types.DBClusterRole 11936 if *v == nil { 11937 sv = &types.DBClusterRole{} 11938 } else { 11939 sv = *v 11940 } 11941 11942 for { 11943 t, done, err := decoder.Token() 11944 if err != nil { 11945 return err 11946 } 11947 if done { 11948 break 11949 } 11950 originalDecoder := decoder 11951 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11952 switch { 11953 case strings.EqualFold("FeatureName", t.Name.Local): 11954 val, err := decoder.Value() 11955 if err != nil { 11956 return err 11957 } 11958 if val == nil { 11959 break 11960 } 11961 { 11962 xtv := string(val) 11963 sv.FeatureName = ptr.String(xtv) 11964 } 11965 11966 case strings.EqualFold("RoleArn", t.Name.Local): 11967 val, err := decoder.Value() 11968 if err != nil { 11969 return err 11970 } 11971 if val == nil { 11972 break 11973 } 11974 { 11975 xtv := string(val) 11976 sv.RoleArn = ptr.String(xtv) 11977 } 11978 11979 case strings.EqualFold("Status", t.Name.Local): 11980 val, err := decoder.Value() 11981 if err != nil { 11982 return err 11983 } 11984 if val == nil { 11985 break 11986 } 11987 { 11988 xtv := string(val) 11989 sv.Status = ptr.String(xtv) 11990 } 11991 11992 default: 11993 // Do nothing and ignore the unexpected tag element 11994 err = decoder.Decoder.Skip() 11995 if err != nil { 11996 return err 11997 } 11998 11999 } 12000 decoder = originalDecoder 12001 } 12002 *v = sv 12003 return nil 12004} 12005 12006func awsAwsquery_deserializeDocumentDBClusterRoleAlreadyExistsFault(v **types.DBClusterRoleAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 12007 if v == nil { 12008 return fmt.Errorf("unexpected nil of type %T", v) 12009 } 12010 var sv *types.DBClusterRoleAlreadyExistsFault 12011 if *v == nil { 12012 sv = &types.DBClusterRoleAlreadyExistsFault{} 12013 } else { 12014 sv = *v 12015 } 12016 12017 for { 12018 t, done, err := decoder.Token() 12019 if err != nil { 12020 return err 12021 } 12022 if done { 12023 break 12024 } 12025 originalDecoder := decoder 12026 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12027 switch { 12028 case strings.EqualFold("message", 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.Message = ptr.String(xtv) 12039 } 12040 12041 default: 12042 // Do nothing and ignore the unexpected tag element 12043 err = decoder.Decoder.Skip() 12044 if err != nil { 12045 return err 12046 } 12047 12048 } 12049 decoder = originalDecoder 12050 } 12051 *v = sv 12052 return nil 12053} 12054 12055func awsAwsquery_deserializeDocumentDBClusterRoleNotFoundFault(v **types.DBClusterRoleNotFoundFault, decoder smithyxml.NodeDecoder) error { 12056 if v == nil { 12057 return fmt.Errorf("unexpected nil of type %T", v) 12058 } 12059 var sv *types.DBClusterRoleNotFoundFault 12060 if *v == nil { 12061 sv = &types.DBClusterRoleNotFoundFault{} 12062 } else { 12063 sv = *v 12064 } 12065 12066 for { 12067 t, done, err := decoder.Token() 12068 if err != nil { 12069 return err 12070 } 12071 if done { 12072 break 12073 } 12074 originalDecoder := decoder 12075 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12076 switch { 12077 case strings.EqualFold("message", t.Name.Local): 12078 val, err := decoder.Value() 12079 if err != nil { 12080 return err 12081 } 12082 if val == nil { 12083 break 12084 } 12085 { 12086 xtv := string(val) 12087 sv.Message = ptr.String(xtv) 12088 } 12089 12090 default: 12091 // Do nothing and ignore the unexpected tag element 12092 err = decoder.Decoder.Skip() 12093 if err != nil { 12094 return err 12095 } 12096 12097 } 12098 decoder = originalDecoder 12099 } 12100 *v = sv 12101 return nil 12102} 12103 12104func awsAwsquery_deserializeDocumentDBClusterRoleQuotaExceededFault(v **types.DBClusterRoleQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 12105 if v == nil { 12106 return fmt.Errorf("unexpected nil of type %T", v) 12107 } 12108 var sv *types.DBClusterRoleQuotaExceededFault 12109 if *v == nil { 12110 sv = &types.DBClusterRoleQuotaExceededFault{} 12111 } else { 12112 sv = *v 12113 } 12114 12115 for { 12116 t, done, err := decoder.Token() 12117 if err != nil { 12118 return err 12119 } 12120 if done { 12121 break 12122 } 12123 originalDecoder := decoder 12124 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12125 switch { 12126 case strings.EqualFold("message", t.Name.Local): 12127 val, err := decoder.Value() 12128 if err != nil { 12129 return err 12130 } 12131 if val == nil { 12132 break 12133 } 12134 { 12135 xtv := string(val) 12136 sv.Message = ptr.String(xtv) 12137 } 12138 12139 default: 12140 // Do nothing and ignore the unexpected tag element 12141 err = decoder.Decoder.Skip() 12142 if err != nil { 12143 return err 12144 } 12145 12146 } 12147 decoder = originalDecoder 12148 } 12149 *v = sv 12150 return nil 12151} 12152 12153func awsAwsquery_deserializeDocumentDBClusterRoles(v *[]types.DBClusterRole, decoder smithyxml.NodeDecoder) error { 12154 if v == nil { 12155 return fmt.Errorf("unexpected nil of type %T", v) 12156 } 12157 var sv []types.DBClusterRole 12158 if *v == nil { 12159 sv = make([]types.DBClusterRole, 0) 12160 } else { 12161 sv = *v 12162 } 12163 12164 originalDecoder := decoder 12165 for { 12166 t, done, err := decoder.Token() 12167 if err != nil { 12168 return err 12169 } 12170 if done { 12171 break 12172 } 12173 switch { 12174 case strings.EqualFold("DBClusterRole", t.Name.Local): 12175 var col types.DBClusterRole 12176 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12177 destAddr := &col 12178 if err := awsAwsquery_deserializeDocumentDBClusterRole(&destAddr, nodeDecoder); err != nil { 12179 return err 12180 } 12181 col = *destAddr 12182 sv = append(sv, col) 12183 12184 default: 12185 err = decoder.Decoder.Skip() 12186 if err != nil { 12187 return err 12188 } 12189 12190 } 12191 decoder = originalDecoder 12192 } 12193 *v = sv 12194 return nil 12195} 12196 12197func awsAwsquery_deserializeDocumentDBClusterRolesUnwrapped(v *[]types.DBClusterRole, decoder smithyxml.NodeDecoder) error { 12198 var sv []types.DBClusterRole 12199 if *v == nil { 12200 sv = make([]types.DBClusterRole, 0) 12201 } else { 12202 sv = *v 12203 } 12204 12205 switch { 12206 default: 12207 var mv types.DBClusterRole 12208 t := decoder.StartEl 12209 _ = t 12210 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12211 destAddr := &mv 12212 if err := awsAwsquery_deserializeDocumentDBClusterRole(&destAddr, nodeDecoder); err != nil { 12213 return err 12214 } 12215 mv = *destAddr 12216 sv = append(sv, mv) 12217 } 12218 *v = sv 12219 return nil 12220} 12221func awsAwsquery_deserializeDocumentDBClusterSnapshot(v **types.DBClusterSnapshot, decoder smithyxml.NodeDecoder) error { 12222 if v == nil { 12223 return fmt.Errorf("unexpected nil of type %T", v) 12224 } 12225 var sv *types.DBClusterSnapshot 12226 if *v == nil { 12227 sv = &types.DBClusterSnapshot{} 12228 } else { 12229 sv = *v 12230 } 12231 12232 for { 12233 t, done, err := decoder.Token() 12234 if err != nil { 12235 return err 12236 } 12237 if done { 12238 break 12239 } 12240 originalDecoder := decoder 12241 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12242 switch { 12243 case strings.EqualFold("AllocatedStorage", t.Name.Local): 12244 val, err := decoder.Value() 12245 if err != nil { 12246 return err 12247 } 12248 if val == nil { 12249 break 12250 } 12251 { 12252 xtv := string(val) 12253 i64, err := strconv.ParseInt(xtv, 10, 64) 12254 if err != nil { 12255 return err 12256 } 12257 sv.AllocatedStorage = int32(i64) 12258 } 12259 12260 case strings.EqualFold("AvailabilityZones", t.Name.Local): 12261 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12262 if err := awsAwsquery_deserializeDocumentAvailabilityZones(&sv.AvailabilityZones, nodeDecoder); err != nil { 12263 return err 12264 } 12265 12266 case strings.EqualFold("ClusterCreateTime", t.Name.Local): 12267 val, err := decoder.Value() 12268 if err != nil { 12269 return err 12270 } 12271 if val == nil { 12272 break 12273 } 12274 { 12275 xtv := string(val) 12276 t, err := smithytime.ParseDateTime(xtv) 12277 if err != nil { 12278 return err 12279 } 12280 sv.ClusterCreateTime = ptr.Time(t) 12281 } 12282 12283 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 12284 val, err := decoder.Value() 12285 if err != nil { 12286 return err 12287 } 12288 if val == nil { 12289 break 12290 } 12291 { 12292 xtv := string(val) 12293 sv.DBClusterIdentifier = ptr.String(xtv) 12294 } 12295 12296 case strings.EqualFold("DBClusterSnapshotArn", t.Name.Local): 12297 val, err := decoder.Value() 12298 if err != nil { 12299 return err 12300 } 12301 if val == nil { 12302 break 12303 } 12304 { 12305 xtv := string(val) 12306 sv.DBClusterSnapshotArn = ptr.String(xtv) 12307 } 12308 12309 case strings.EqualFold("DBClusterSnapshotIdentifier", t.Name.Local): 12310 val, err := decoder.Value() 12311 if err != nil { 12312 return err 12313 } 12314 if val == nil { 12315 break 12316 } 12317 { 12318 xtv := string(val) 12319 sv.DBClusterSnapshotIdentifier = ptr.String(xtv) 12320 } 12321 12322 case strings.EqualFold("Engine", t.Name.Local): 12323 val, err := decoder.Value() 12324 if err != nil { 12325 return err 12326 } 12327 if val == nil { 12328 break 12329 } 12330 { 12331 xtv := string(val) 12332 sv.Engine = ptr.String(xtv) 12333 } 12334 12335 case strings.EqualFold("EngineVersion", t.Name.Local): 12336 val, err := decoder.Value() 12337 if err != nil { 12338 return err 12339 } 12340 if val == nil { 12341 break 12342 } 12343 { 12344 xtv := string(val) 12345 sv.EngineVersion = ptr.String(xtv) 12346 } 12347 12348 case strings.EqualFold("IAMDatabaseAuthenticationEnabled", t.Name.Local): 12349 val, err := decoder.Value() 12350 if err != nil { 12351 return err 12352 } 12353 if val == nil { 12354 break 12355 } 12356 { 12357 xtv, err := strconv.ParseBool(string(val)) 12358 if err != nil { 12359 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 12360 } 12361 sv.IAMDatabaseAuthenticationEnabled = xtv 12362 } 12363 12364 case strings.EqualFold("KmsKeyId", 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 sv.KmsKeyId = ptr.String(xtv) 12375 } 12376 12377 case strings.EqualFold("LicenseModel", t.Name.Local): 12378 val, err := decoder.Value() 12379 if err != nil { 12380 return err 12381 } 12382 if val == nil { 12383 break 12384 } 12385 { 12386 xtv := string(val) 12387 sv.LicenseModel = ptr.String(xtv) 12388 } 12389 12390 case strings.EqualFold("MasterUsername", t.Name.Local): 12391 val, err := decoder.Value() 12392 if err != nil { 12393 return err 12394 } 12395 if val == nil { 12396 break 12397 } 12398 { 12399 xtv := string(val) 12400 sv.MasterUsername = ptr.String(xtv) 12401 } 12402 12403 case strings.EqualFold("PercentProgress", t.Name.Local): 12404 val, err := decoder.Value() 12405 if err != nil { 12406 return err 12407 } 12408 if val == nil { 12409 break 12410 } 12411 { 12412 xtv := string(val) 12413 i64, err := strconv.ParseInt(xtv, 10, 64) 12414 if err != nil { 12415 return err 12416 } 12417 sv.PercentProgress = int32(i64) 12418 } 12419 12420 case strings.EqualFold("Port", t.Name.Local): 12421 val, err := decoder.Value() 12422 if err != nil { 12423 return err 12424 } 12425 if val == nil { 12426 break 12427 } 12428 { 12429 xtv := string(val) 12430 i64, err := strconv.ParseInt(xtv, 10, 64) 12431 if err != nil { 12432 return err 12433 } 12434 sv.Port = int32(i64) 12435 } 12436 12437 case strings.EqualFold("SnapshotCreateTime", t.Name.Local): 12438 val, err := decoder.Value() 12439 if err != nil { 12440 return err 12441 } 12442 if val == nil { 12443 break 12444 } 12445 { 12446 xtv := string(val) 12447 t, err := smithytime.ParseDateTime(xtv) 12448 if err != nil { 12449 return err 12450 } 12451 sv.SnapshotCreateTime = ptr.Time(t) 12452 } 12453 12454 case strings.EqualFold("SnapshotType", t.Name.Local): 12455 val, err := decoder.Value() 12456 if err != nil { 12457 return err 12458 } 12459 if val == nil { 12460 break 12461 } 12462 { 12463 xtv := string(val) 12464 sv.SnapshotType = ptr.String(xtv) 12465 } 12466 12467 case strings.EqualFold("SourceDBClusterSnapshotArn", t.Name.Local): 12468 val, err := decoder.Value() 12469 if err != nil { 12470 return err 12471 } 12472 if val == nil { 12473 break 12474 } 12475 { 12476 xtv := string(val) 12477 sv.SourceDBClusterSnapshotArn = ptr.String(xtv) 12478 } 12479 12480 case strings.EqualFold("Status", t.Name.Local): 12481 val, err := decoder.Value() 12482 if err != nil { 12483 return err 12484 } 12485 if val == nil { 12486 break 12487 } 12488 { 12489 xtv := string(val) 12490 sv.Status = ptr.String(xtv) 12491 } 12492 12493 case strings.EqualFold("StorageEncrypted", t.Name.Local): 12494 val, err := decoder.Value() 12495 if err != nil { 12496 return err 12497 } 12498 if val == nil { 12499 break 12500 } 12501 { 12502 xtv, err := strconv.ParseBool(string(val)) 12503 if err != nil { 12504 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 12505 } 12506 sv.StorageEncrypted = xtv 12507 } 12508 12509 case strings.EqualFold("VpcId", t.Name.Local): 12510 val, err := decoder.Value() 12511 if err != nil { 12512 return err 12513 } 12514 if val == nil { 12515 break 12516 } 12517 { 12518 xtv := string(val) 12519 sv.VpcId = ptr.String(xtv) 12520 } 12521 12522 default: 12523 // Do nothing and ignore the unexpected tag element 12524 err = decoder.Decoder.Skip() 12525 if err != nil { 12526 return err 12527 } 12528 12529 } 12530 decoder = originalDecoder 12531 } 12532 *v = sv 12533 return nil 12534} 12535 12536func awsAwsquery_deserializeDocumentDBClusterSnapshotAlreadyExistsFault(v **types.DBClusterSnapshotAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 12537 if v == nil { 12538 return fmt.Errorf("unexpected nil of type %T", v) 12539 } 12540 var sv *types.DBClusterSnapshotAlreadyExistsFault 12541 if *v == nil { 12542 sv = &types.DBClusterSnapshotAlreadyExistsFault{} 12543 } else { 12544 sv = *v 12545 } 12546 12547 for { 12548 t, done, err := decoder.Token() 12549 if err != nil { 12550 return err 12551 } 12552 if done { 12553 break 12554 } 12555 originalDecoder := decoder 12556 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12557 switch { 12558 case strings.EqualFold("message", t.Name.Local): 12559 val, err := decoder.Value() 12560 if err != nil { 12561 return err 12562 } 12563 if val == nil { 12564 break 12565 } 12566 { 12567 xtv := string(val) 12568 sv.Message = ptr.String(xtv) 12569 } 12570 12571 default: 12572 // Do nothing and ignore the unexpected tag element 12573 err = decoder.Decoder.Skip() 12574 if err != nil { 12575 return err 12576 } 12577 12578 } 12579 decoder = originalDecoder 12580 } 12581 *v = sv 12582 return nil 12583} 12584 12585func awsAwsquery_deserializeDocumentDBClusterSnapshotAttribute(v **types.DBClusterSnapshotAttribute, decoder smithyxml.NodeDecoder) error { 12586 if v == nil { 12587 return fmt.Errorf("unexpected nil of type %T", v) 12588 } 12589 var sv *types.DBClusterSnapshotAttribute 12590 if *v == nil { 12591 sv = &types.DBClusterSnapshotAttribute{} 12592 } else { 12593 sv = *v 12594 } 12595 12596 for { 12597 t, done, err := decoder.Token() 12598 if err != nil { 12599 return err 12600 } 12601 if done { 12602 break 12603 } 12604 originalDecoder := decoder 12605 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12606 switch { 12607 case strings.EqualFold("AttributeName", t.Name.Local): 12608 val, err := decoder.Value() 12609 if err != nil { 12610 return err 12611 } 12612 if val == nil { 12613 break 12614 } 12615 { 12616 xtv := string(val) 12617 sv.AttributeName = ptr.String(xtv) 12618 } 12619 12620 case strings.EqualFold("AttributeValues", t.Name.Local): 12621 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12622 if err := awsAwsquery_deserializeDocumentAttributeValueList(&sv.AttributeValues, nodeDecoder); err != nil { 12623 return err 12624 } 12625 12626 default: 12627 // Do nothing and ignore the unexpected tag element 12628 err = decoder.Decoder.Skip() 12629 if err != nil { 12630 return err 12631 } 12632 12633 } 12634 decoder = originalDecoder 12635 } 12636 *v = sv 12637 return nil 12638} 12639 12640func awsAwsquery_deserializeDocumentDBClusterSnapshotAttributeList(v *[]types.DBClusterSnapshotAttribute, decoder smithyxml.NodeDecoder) error { 12641 if v == nil { 12642 return fmt.Errorf("unexpected nil of type %T", v) 12643 } 12644 var sv []types.DBClusterSnapshotAttribute 12645 if *v == nil { 12646 sv = make([]types.DBClusterSnapshotAttribute, 0) 12647 } else { 12648 sv = *v 12649 } 12650 12651 originalDecoder := decoder 12652 for { 12653 t, done, err := decoder.Token() 12654 if err != nil { 12655 return err 12656 } 12657 if done { 12658 break 12659 } 12660 switch { 12661 case strings.EqualFold("DBClusterSnapshotAttribute", t.Name.Local): 12662 var col types.DBClusterSnapshotAttribute 12663 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12664 destAddr := &col 12665 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttribute(&destAddr, nodeDecoder); err != nil { 12666 return err 12667 } 12668 col = *destAddr 12669 sv = append(sv, col) 12670 12671 default: 12672 err = decoder.Decoder.Skip() 12673 if err != nil { 12674 return err 12675 } 12676 12677 } 12678 decoder = originalDecoder 12679 } 12680 *v = sv 12681 return nil 12682} 12683 12684func awsAwsquery_deserializeDocumentDBClusterSnapshotAttributeListUnwrapped(v *[]types.DBClusterSnapshotAttribute, decoder smithyxml.NodeDecoder) error { 12685 var sv []types.DBClusterSnapshotAttribute 12686 if *v == nil { 12687 sv = make([]types.DBClusterSnapshotAttribute, 0) 12688 } else { 12689 sv = *v 12690 } 12691 12692 switch { 12693 default: 12694 var mv types.DBClusterSnapshotAttribute 12695 t := decoder.StartEl 12696 _ = t 12697 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12698 destAddr := &mv 12699 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttribute(&destAddr, nodeDecoder); err != nil { 12700 return err 12701 } 12702 mv = *destAddr 12703 sv = append(sv, mv) 12704 } 12705 *v = sv 12706 return nil 12707} 12708func awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(v **types.DBClusterSnapshotAttributesResult, decoder smithyxml.NodeDecoder) error { 12709 if v == nil { 12710 return fmt.Errorf("unexpected nil of type %T", v) 12711 } 12712 var sv *types.DBClusterSnapshotAttributesResult 12713 if *v == nil { 12714 sv = &types.DBClusterSnapshotAttributesResult{} 12715 } else { 12716 sv = *v 12717 } 12718 12719 for { 12720 t, done, err := decoder.Token() 12721 if err != nil { 12722 return err 12723 } 12724 if done { 12725 break 12726 } 12727 originalDecoder := decoder 12728 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12729 switch { 12730 case strings.EqualFold("DBClusterSnapshotAttributes", t.Name.Local): 12731 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12732 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributeList(&sv.DBClusterSnapshotAttributes, nodeDecoder); err != nil { 12733 return err 12734 } 12735 12736 case strings.EqualFold("DBClusterSnapshotIdentifier", t.Name.Local): 12737 val, err := decoder.Value() 12738 if err != nil { 12739 return err 12740 } 12741 if val == nil { 12742 break 12743 } 12744 { 12745 xtv := string(val) 12746 sv.DBClusterSnapshotIdentifier = ptr.String(xtv) 12747 } 12748 12749 default: 12750 // Do nothing and ignore the unexpected tag element 12751 err = decoder.Decoder.Skip() 12752 if err != nil { 12753 return err 12754 } 12755 12756 } 12757 decoder = originalDecoder 12758 } 12759 *v = sv 12760 return nil 12761} 12762 12763func awsAwsquery_deserializeDocumentDBClusterSnapshotList(v *[]types.DBClusterSnapshot, decoder smithyxml.NodeDecoder) error { 12764 if v == nil { 12765 return fmt.Errorf("unexpected nil of type %T", v) 12766 } 12767 var sv []types.DBClusterSnapshot 12768 if *v == nil { 12769 sv = make([]types.DBClusterSnapshot, 0) 12770 } else { 12771 sv = *v 12772 } 12773 12774 originalDecoder := decoder 12775 for { 12776 t, done, err := decoder.Token() 12777 if err != nil { 12778 return err 12779 } 12780 if done { 12781 break 12782 } 12783 switch { 12784 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 12785 var col types.DBClusterSnapshot 12786 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12787 destAddr := &col 12788 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&destAddr, nodeDecoder); err != nil { 12789 return err 12790 } 12791 col = *destAddr 12792 sv = append(sv, col) 12793 12794 default: 12795 err = decoder.Decoder.Skip() 12796 if err != nil { 12797 return err 12798 } 12799 12800 } 12801 decoder = originalDecoder 12802 } 12803 *v = sv 12804 return nil 12805} 12806 12807func awsAwsquery_deserializeDocumentDBClusterSnapshotListUnwrapped(v *[]types.DBClusterSnapshot, decoder smithyxml.NodeDecoder) error { 12808 var sv []types.DBClusterSnapshot 12809 if *v == nil { 12810 sv = make([]types.DBClusterSnapshot, 0) 12811 } else { 12812 sv = *v 12813 } 12814 12815 switch { 12816 default: 12817 var mv types.DBClusterSnapshot 12818 t := decoder.StartEl 12819 _ = t 12820 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12821 destAddr := &mv 12822 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&destAddr, nodeDecoder); err != nil { 12823 return err 12824 } 12825 mv = *destAddr 12826 sv = append(sv, mv) 12827 } 12828 *v = sv 12829 return nil 12830} 12831func awsAwsquery_deserializeDocumentDBClusterSnapshotNotFoundFault(v **types.DBClusterSnapshotNotFoundFault, decoder smithyxml.NodeDecoder) error { 12832 if v == nil { 12833 return fmt.Errorf("unexpected nil of type %T", v) 12834 } 12835 var sv *types.DBClusterSnapshotNotFoundFault 12836 if *v == nil { 12837 sv = &types.DBClusterSnapshotNotFoundFault{} 12838 } else { 12839 sv = *v 12840 } 12841 12842 for { 12843 t, done, err := decoder.Token() 12844 if err != nil { 12845 return err 12846 } 12847 if done { 12848 break 12849 } 12850 originalDecoder := decoder 12851 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12852 switch { 12853 case strings.EqualFold("message", t.Name.Local): 12854 val, err := decoder.Value() 12855 if err != nil { 12856 return err 12857 } 12858 if val == nil { 12859 break 12860 } 12861 { 12862 xtv := string(val) 12863 sv.Message = ptr.String(xtv) 12864 } 12865 12866 default: 12867 // Do nothing and ignore the unexpected tag element 12868 err = decoder.Decoder.Skip() 12869 if err != nil { 12870 return err 12871 } 12872 12873 } 12874 decoder = originalDecoder 12875 } 12876 *v = sv 12877 return nil 12878} 12879 12880func awsAwsquery_deserializeDocumentDBEngineVersion(v **types.DBEngineVersion, decoder smithyxml.NodeDecoder) error { 12881 if v == nil { 12882 return fmt.Errorf("unexpected nil of type %T", v) 12883 } 12884 var sv *types.DBEngineVersion 12885 if *v == nil { 12886 sv = &types.DBEngineVersion{} 12887 } else { 12888 sv = *v 12889 } 12890 12891 for { 12892 t, done, err := decoder.Token() 12893 if err != nil { 12894 return err 12895 } 12896 if done { 12897 break 12898 } 12899 originalDecoder := decoder 12900 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12901 switch { 12902 case strings.EqualFold("DBEngineDescription", t.Name.Local): 12903 val, err := decoder.Value() 12904 if err != nil { 12905 return err 12906 } 12907 if val == nil { 12908 break 12909 } 12910 { 12911 xtv := string(val) 12912 sv.DBEngineDescription = ptr.String(xtv) 12913 } 12914 12915 case strings.EqualFold("DBEngineVersionDescription", t.Name.Local): 12916 val, err := decoder.Value() 12917 if err != nil { 12918 return err 12919 } 12920 if val == nil { 12921 break 12922 } 12923 { 12924 xtv := string(val) 12925 sv.DBEngineVersionDescription = ptr.String(xtv) 12926 } 12927 12928 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 12929 val, err := decoder.Value() 12930 if err != nil { 12931 return err 12932 } 12933 if val == nil { 12934 break 12935 } 12936 { 12937 xtv := string(val) 12938 sv.DBParameterGroupFamily = ptr.String(xtv) 12939 } 12940 12941 case strings.EqualFold("DefaultCharacterSet", t.Name.Local): 12942 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12943 if err := awsAwsquery_deserializeDocumentCharacterSet(&sv.DefaultCharacterSet, nodeDecoder); err != nil { 12944 return err 12945 } 12946 12947 case strings.EqualFold("Engine", t.Name.Local): 12948 val, err := decoder.Value() 12949 if err != nil { 12950 return err 12951 } 12952 if val == nil { 12953 break 12954 } 12955 { 12956 xtv := string(val) 12957 sv.Engine = ptr.String(xtv) 12958 } 12959 12960 case strings.EqualFold("EngineVersion", t.Name.Local): 12961 val, err := decoder.Value() 12962 if err != nil { 12963 return err 12964 } 12965 if val == nil { 12966 break 12967 } 12968 { 12969 xtv := string(val) 12970 sv.EngineVersion = ptr.String(xtv) 12971 } 12972 12973 case strings.EqualFold("ExportableLogTypes", t.Name.Local): 12974 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12975 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.ExportableLogTypes, nodeDecoder); err != nil { 12976 return err 12977 } 12978 12979 case strings.EqualFold("SupportedCharacterSets", t.Name.Local): 12980 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12981 if err := awsAwsquery_deserializeDocumentSupportedCharacterSetsList(&sv.SupportedCharacterSets, nodeDecoder); err != nil { 12982 return err 12983 } 12984 12985 case strings.EqualFold("SupportedTimezones", t.Name.Local): 12986 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12987 if err := awsAwsquery_deserializeDocumentSupportedTimezonesList(&sv.SupportedTimezones, nodeDecoder); err != nil { 12988 return err 12989 } 12990 12991 case strings.EqualFold("SupportsLogExportsToCloudwatchLogs", t.Name.Local): 12992 val, err := decoder.Value() 12993 if err != nil { 12994 return err 12995 } 12996 if val == nil { 12997 break 12998 } 12999 { 13000 xtv, err := strconv.ParseBool(string(val)) 13001 if err != nil { 13002 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13003 } 13004 sv.SupportsLogExportsToCloudwatchLogs = xtv 13005 } 13006 13007 case strings.EqualFold("SupportsReadReplica", t.Name.Local): 13008 val, err := decoder.Value() 13009 if err != nil { 13010 return err 13011 } 13012 if val == nil { 13013 break 13014 } 13015 { 13016 xtv, err := strconv.ParseBool(string(val)) 13017 if err != nil { 13018 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13019 } 13020 sv.SupportsReadReplica = xtv 13021 } 13022 13023 case strings.EqualFold("ValidUpgradeTarget", t.Name.Local): 13024 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13025 if err := awsAwsquery_deserializeDocumentValidUpgradeTargetList(&sv.ValidUpgradeTarget, nodeDecoder); err != nil { 13026 return err 13027 } 13028 13029 default: 13030 // Do nothing and ignore the unexpected tag element 13031 err = decoder.Decoder.Skip() 13032 if err != nil { 13033 return err 13034 } 13035 13036 } 13037 decoder = originalDecoder 13038 } 13039 *v = sv 13040 return nil 13041} 13042 13043func awsAwsquery_deserializeDocumentDBEngineVersionList(v *[]types.DBEngineVersion, decoder smithyxml.NodeDecoder) error { 13044 if v == nil { 13045 return fmt.Errorf("unexpected nil of type %T", v) 13046 } 13047 var sv []types.DBEngineVersion 13048 if *v == nil { 13049 sv = make([]types.DBEngineVersion, 0) 13050 } else { 13051 sv = *v 13052 } 13053 13054 originalDecoder := decoder 13055 for { 13056 t, done, err := decoder.Token() 13057 if err != nil { 13058 return err 13059 } 13060 if done { 13061 break 13062 } 13063 switch { 13064 case strings.EqualFold("DBEngineVersion", t.Name.Local): 13065 var col types.DBEngineVersion 13066 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13067 destAddr := &col 13068 if err := awsAwsquery_deserializeDocumentDBEngineVersion(&destAddr, nodeDecoder); err != nil { 13069 return err 13070 } 13071 col = *destAddr 13072 sv = append(sv, col) 13073 13074 default: 13075 err = decoder.Decoder.Skip() 13076 if err != nil { 13077 return err 13078 } 13079 13080 } 13081 decoder = originalDecoder 13082 } 13083 *v = sv 13084 return nil 13085} 13086 13087func awsAwsquery_deserializeDocumentDBEngineVersionListUnwrapped(v *[]types.DBEngineVersion, decoder smithyxml.NodeDecoder) error { 13088 var sv []types.DBEngineVersion 13089 if *v == nil { 13090 sv = make([]types.DBEngineVersion, 0) 13091 } else { 13092 sv = *v 13093 } 13094 13095 switch { 13096 default: 13097 var mv types.DBEngineVersion 13098 t := decoder.StartEl 13099 _ = t 13100 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13101 destAddr := &mv 13102 if err := awsAwsquery_deserializeDocumentDBEngineVersion(&destAddr, nodeDecoder); err != nil { 13103 return err 13104 } 13105 mv = *destAddr 13106 sv = append(sv, mv) 13107 } 13108 *v = sv 13109 return nil 13110} 13111func awsAwsquery_deserializeDocumentDBInstance(v **types.DBInstance, decoder smithyxml.NodeDecoder) error { 13112 if v == nil { 13113 return fmt.Errorf("unexpected nil of type %T", v) 13114 } 13115 var sv *types.DBInstance 13116 if *v == nil { 13117 sv = &types.DBInstance{} 13118 } else { 13119 sv = *v 13120 } 13121 13122 for { 13123 t, done, err := decoder.Token() 13124 if err != nil { 13125 return err 13126 } 13127 if done { 13128 break 13129 } 13130 originalDecoder := decoder 13131 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13132 switch { 13133 case strings.EqualFold("AllocatedStorage", t.Name.Local): 13134 val, err := decoder.Value() 13135 if err != nil { 13136 return err 13137 } 13138 if val == nil { 13139 break 13140 } 13141 { 13142 xtv := string(val) 13143 i64, err := strconv.ParseInt(xtv, 10, 64) 13144 if err != nil { 13145 return err 13146 } 13147 sv.AllocatedStorage = int32(i64) 13148 } 13149 13150 case strings.EqualFold("AutoMinorVersionUpgrade", t.Name.Local): 13151 val, err := decoder.Value() 13152 if err != nil { 13153 return err 13154 } 13155 if val == nil { 13156 break 13157 } 13158 { 13159 xtv, err := strconv.ParseBool(string(val)) 13160 if err != nil { 13161 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13162 } 13163 sv.AutoMinorVersionUpgrade = xtv 13164 } 13165 13166 case strings.EqualFold("AvailabilityZone", t.Name.Local): 13167 val, err := decoder.Value() 13168 if err != nil { 13169 return err 13170 } 13171 if val == nil { 13172 break 13173 } 13174 { 13175 xtv := string(val) 13176 sv.AvailabilityZone = ptr.String(xtv) 13177 } 13178 13179 case strings.EqualFold("BackupRetentionPeriod", t.Name.Local): 13180 val, err := decoder.Value() 13181 if err != nil { 13182 return err 13183 } 13184 if val == nil { 13185 break 13186 } 13187 { 13188 xtv := string(val) 13189 i64, err := strconv.ParseInt(xtv, 10, 64) 13190 if err != nil { 13191 return err 13192 } 13193 sv.BackupRetentionPeriod = int32(i64) 13194 } 13195 13196 case strings.EqualFold("CACertificateIdentifier", t.Name.Local): 13197 val, err := decoder.Value() 13198 if err != nil { 13199 return err 13200 } 13201 if val == nil { 13202 break 13203 } 13204 { 13205 xtv := string(val) 13206 sv.CACertificateIdentifier = ptr.String(xtv) 13207 } 13208 13209 case strings.EqualFold("CharacterSetName", t.Name.Local): 13210 val, err := decoder.Value() 13211 if err != nil { 13212 return err 13213 } 13214 if val == nil { 13215 break 13216 } 13217 { 13218 xtv := string(val) 13219 sv.CharacterSetName = ptr.String(xtv) 13220 } 13221 13222 case strings.EqualFold("CopyTagsToSnapshot", t.Name.Local): 13223 val, err := decoder.Value() 13224 if err != nil { 13225 return err 13226 } 13227 if val == nil { 13228 break 13229 } 13230 { 13231 xtv, err := strconv.ParseBool(string(val)) 13232 if err != nil { 13233 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13234 } 13235 sv.CopyTagsToSnapshot = xtv 13236 } 13237 13238 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 13239 val, err := decoder.Value() 13240 if err != nil { 13241 return err 13242 } 13243 if val == nil { 13244 break 13245 } 13246 { 13247 xtv := string(val) 13248 sv.DBClusterIdentifier = ptr.String(xtv) 13249 } 13250 13251 case strings.EqualFold("DBInstanceArn", t.Name.Local): 13252 val, err := decoder.Value() 13253 if err != nil { 13254 return err 13255 } 13256 if val == nil { 13257 break 13258 } 13259 { 13260 xtv := string(val) 13261 sv.DBInstanceArn = ptr.String(xtv) 13262 } 13263 13264 case strings.EqualFold("DBInstanceClass", t.Name.Local): 13265 val, err := decoder.Value() 13266 if err != nil { 13267 return err 13268 } 13269 if val == nil { 13270 break 13271 } 13272 { 13273 xtv := string(val) 13274 sv.DBInstanceClass = ptr.String(xtv) 13275 } 13276 13277 case strings.EqualFold("DBInstanceIdentifier", t.Name.Local): 13278 val, err := decoder.Value() 13279 if err != nil { 13280 return err 13281 } 13282 if val == nil { 13283 break 13284 } 13285 { 13286 xtv := string(val) 13287 sv.DBInstanceIdentifier = ptr.String(xtv) 13288 } 13289 13290 case strings.EqualFold("DbInstancePort", t.Name.Local): 13291 val, err := decoder.Value() 13292 if err != nil { 13293 return err 13294 } 13295 if val == nil { 13296 break 13297 } 13298 { 13299 xtv := string(val) 13300 i64, err := strconv.ParseInt(xtv, 10, 64) 13301 if err != nil { 13302 return err 13303 } 13304 sv.DbInstancePort = int32(i64) 13305 } 13306 13307 case strings.EqualFold("DBInstanceStatus", t.Name.Local): 13308 val, err := decoder.Value() 13309 if err != nil { 13310 return err 13311 } 13312 if val == nil { 13313 break 13314 } 13315 { 13316 xtv := string(val) 13317 sv.DBInstanceStatus = ptr.String(xtv) 13318 } 13319 13320 case strings.EqualFold("DbiResourceId", t.Name.Local): 13321 val, err := decoder.Value() 13322 if err != nil { 13323 return err 13324 } 13325 if val == nil { 13326 break 13327 } 13328 { 13329 xtv := string(val) 13330 sv.DbiResourceId = ptr.String(xtv) 13331 } 13332 13333 case strings.EqualFold("DBName", t.Name.Local): 13334 val, err := decoder.Value() 13335 if err != nil { 13336 return err 13337 } 13338 if val == nil { 13339 break 13340 } 13341 { 13342 xtv := string(val) 13343 sv.DBName = ptr.String(xtv) 13344 } 13345 13346 case strings.EqualFold("DBParameterGroups", t.Name.Local): 13347 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13348 if err := awsAwsquery_deserializeDocumentDBParameterGroupStatusList(&sv.DBParameterGroups, nodeDecoder); err != nil { 13349 return err 13350 } 13351 13352 case strings.EqualFold("DBSecurityGroups", t.Name.Local): 13353 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13354 if err := awsAwsquery_deserializeDocumentDBSecurityGroupMembershipList(&sv.DBSecurityGroups, nodeDecoder); err != nil { 13355 return err 13356 } 13357 13358 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 13359 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13360 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&sv.DBSubnetGroup, nodeDecoder); err != nil { 13361 return err 13362 } 13363 13364 case strings.EqualFold("DeletionProtection", t.Name.Local): 13365 val, err := decoder.Value() 13366 if err != nil { 13367 return err 13368 } 13369 if val == nil { 13370 break 13371 } 13372 { 13373 xtv, err := strconv.ParseBool(string(val)) 13374 if err != nil { 13375 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 13376 } 13377 sv.DeletionProtection = ptr.Bool(xtv) 13378 } 13379 13380 case strings.EqualFold("DomainMemberships", t.Name.Local): 13381 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13382 if err := awsAwsquery_deserializeDocumentDomainMembershipList(&sv.DomainMemberships, nodeDecoder); err != nil { 13383 return err 13384 } 13385 13386 case strings.EqualFold("EnabledCloudwatchLogsExports", t.Name.Local): 13387 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13388 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.EnabledCloudwatchLogsExports, nodeDecoder); err != nil { 13389 return err 13390 } 13391 13392 case strings.EqualFold("Endpoint", t.Name.Local): 13393 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13394 if err := awsAwsquery_deserializeDocumentEndpoint(&sv.Endpoint, nodeDecoder); err != nil { 13395 return err 13396 } 13397 13398 case strings.EqualFold("Engine", t.Name.Local): 13399 val, err := decoder.Value() 13400 if err != nil { 13401 return err 13402 } 13403 if val == nil { 13404 break 13405 } 13406 { 13407 xtv := string(val) 13408 sv.Engine = ptr.String(xtv) 13409 } 13410 13411 case strings.EqualFold("EngineVersion", t.Name.Local): 13412 val, err := decoder.Value() 13413 if err != nil { 13414 return err 13415 } 13416 if val == nil { 13417 break 13418 } 13419 { 13420 xtv := string(val) 13421 sv.EngineVersion = ptr.String(xtv) 13422 } 13423 13424 case strings.EqualFold("EnhancedMonitoringResourceArn", t.Name.Local): 13425 val, err := decoder.Value() 13426 if err != nil { 13427 return err 13428 } 13429 if val == nil { 13430 break 13431 } 13432 { 13433 xtv := string(val) 13434 sv.EnhancedMonitoringResourceArn = ptr.String(xtv) 13435 } 13436 13437 case strings.EqualFold("IAMDatabaseAuthenticationEnabled", t.Name.Local): 13438 val, err := decoder.Value() 13439 if err != nil { 13440 return err 13441 } 13442 if val == nil { 13443 break 13444 } 13445 { 13446 xtv, err := strconv.ParseBool(string(val)) 13447 if err != nil { 13448 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13449 } 13450 sv.IAMDatabaseAuthenticationEnabled = xtv 13451 } 13452 13453 case strings.EqualFold("InstanceCreateTime", t.Name.Local): 13454 val, err := decoder.Value() 13455 if err != nil { 13456 return err 13457 } 13458 if val == nil { 13459 break 13460 } 13461 { 13462 xtv := string(val) 13463 t, err := smithytime.ParseDateTime(xtv) 13464 if err != nil { 13465 return err 13466 } 13467 sv.InstanceCreateTime = ptr.Time(t) 13468 } 13469 13470 case strings.EqualFold("Iops", t.Name.Local): 13471 val, err := decoder.Value() 13472 if err != nil { 13473 return err 13474 } 13475 if val == nil { 13476 break 13477 } 13478 { 13479 xtv := string(val) 13480 i64, err := strconv.ParseInt(xtv, 10, 64) 13481 if err != nil { 13482 return err 13483 } 13484 sv.Iops = ptr.Int32(int32(i64)) 13485 } 13486 13487 case strings.EqualFold("KmsKeyId", t.Name.Local): 13488 val, err := decoder.Value() 13489 if err != nil { 13490 return err 13491 } 13492 if val == nil { 13493 break 13494 } 13495 { 13496 xtv := string(val) 13497 sv.KmsKeyId = ptr.String(xtv) 13498 } 13499 13500 case strings.EqualFold("LatestRestorableTime", t.Name.Local): 13501 val, err := decoder.Value() 13502 if err != nil { 13503 return err 13504 } 13505 if val == nil { 13506 break 13507 } 13508 { 13509 xtv := string(val) 13510 t, err := smithytime.ParseDateTime(xtv) 13511 if err != nil { 13512 return err 13513 } 13514 sv.LatestRestorableTime = ptr.Time(t) 13515 } 13516 13517 case strings.EqualFold("LicenseModel", t.Name.Local): 13518 val, err := decoder.Value() 13519 if err != nil { 13520 return err 13521 } 13522 if val == nil { 13523 break 13524 } 13525 { 13526 xtv := string(val) 13527 sv.LicenseModel = ptr.String(xtv) 13528 } 13529 13530 case strings.EqualFold("MasterUsername", t.Name.Local): 13531 val, err := decoder.Value() 13532 if err != nil { 13533 return err 13534 } 13535 if val == nil { 13536 break 13537 } 13538 { 13539 xtv := string(val) 13540 sv.MasterUsername = ptr.String(xtv) 13541 } 13542 13543 case strings.EqualFold("MonitoringInterval", t.Name.Local): 13544 val, err := decoder.Value() 13545 if err != nil { 13546 return err 13547 } 13548 if val == nil { 13549 break 13550 } 13551 { 13552 xtv := string(val) 13553 i64, err := strconv.ParseInt(xtv, 10, 64) 13554 if err != nil { 13555 return err 13556 } 13557 sv.MonitoringInterval = ptr.Int32(int32(i64)) 13558 } 13559 13560 case strings.EqualFold("MonitoringRoleArn", t.Name.Local): 13561 val, err := decoder.Value() 13562 if err != nil { 13563 return err 13564 } 13565 if val == nil { 13566 break 13567 } 13568 { 13569 xtv := string(val) 13570 sv.MonitoringRoleArn = ptr.String(xtv) 13571 } 13572 13573 case strings.EqualFold("MultiAZ", t.Name.Local): 13574 val, err := decoder.Value() 13575 if err != nil { 13576 return err 13577 } 13578 if val == nil { 13579 break 13580 } 13581 { 13582 xtv, err := strconv.ParseBool(string(val)) 13583 if err != nil { 13584 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13585 } 13586 sv.MultiAZ = xtv 13587 } 13588 13589 case strings.EqualFold("OptionGroupMemberships", t.Name.Local): 13590 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13591 if err := awsAwsquery_deserializeDocumentOptionGroupMembershipList(&sv.OptionGroupMemberships, nodeDecoder); err != nil { 13592 return err 13593 } 13594 13595 case strings.EqualFold("PendingModifiedValues", t.Name.Local): 13596 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13597 if err := awsAwsquery_deserializeDocumentPendingModifiedValues(&sv.PendingModifiedValues, nodeDecoder); err != nil { 13598 return err 13599 } 13600 13601 case strings.EqualFold("PerformanceInsightsEnabled", t.Name.Local): 13602 val, err := decoder.Value() 13603 if err != nil { 13604 return err 13605 } 13606 if val == nil { 13607 break 13608 } 13609 { 13610 xtv, err := strconv.ParseBool(string(val)) 13611 if err != nil { 13612 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 13613 } 13614 sv.PerformanceInsightsEnabled = ptr.Bool(xtv) 13615 } 13616 13617 case strings.EqualFold("PerformanceInsightsKMSKeyId", t.Name.Local): 13618 val, err := decoder.Value() 13619 if err != nil { 13620 return err 13621 } 13622 if val == nil { 13623 break 13624 } 13625 { 13626 xtv := string(val) 13627 sv.PerformanceInsightsKMSKeyId = ptr.String(xtv) 13628 } 13629 13630 case strings.EqualFold("PreferredBackupWindow", t.Name.Local): 13631 val, err := decoder.Value() 13632 if err != nil { 13633 return err 13634 } 13635 if val == nil { 13636 break 13637 } 13638 { 13639 xtv := string(val) 13640 sv.PreferredBackupWindow = ptr.String(xtv) 13641 } 13642 13643 case strings.EqualFold("PreferredMaintenanceWindow", t.Name.Local): 13644 val, err := decoder.Value() 13645 if err != nil { 13646 return err 13647 } 13648 if val == nil { 13649 break 13650 } 13651 { 13652 xtv := string(val) 13653 sv.PreferredMaintenanceWindow = ptr.String(xtv) 13654 } 13655 13656 case strings.EqualFold("PromotionTier", t.Name.Local): 13657 val, err := decoder.Value() 13658 if err != nil { 13659 return err 13660 } 13661 if val == nil { 13662 break 13663 } 13664 { 13665 xtv := string(val) 13666 i64, err := strconv.ParseInt(xtv, 10, 64) 13667 if err != nil { 13668 return err 13669 } 13670 sv.PromotionTier = ptr.Int32(int32(i64)) 13671 } 13672 13673 case strings.EqualFold("PubliclyAccessible", t.Name.Local): 13674 val, err := decoder.Value() 13675 if err != nil { 13676 return err 13677 } 13678 if val == nil { 13679 break 13680 } 13681 { 13682 xtv, err := strconv.ParseBool(string(val)) 13683 if err != nil { 13684 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13685 } 13686 sv.PubliclyAccessible = xtv 13687 } 13688 13689 case strings.EqualFold("ReadReplicaDBClusterIdentifiers", t.Name.Local): 13690 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13691 if err := awsAwsquery_deserializeDocumentReadReplicaDBClusterIdentifierList(&sv.ReadReplicaDBClusterIdentifiers, nodeDecoder); err != nil { 13692 return err 13693 } 13694 13695 case strings.EqualFold("ReadReplicaDBInstanceIdentifiers", t.Name.Local): 13696 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13697 if err := awsAwsquery_deserializeDocumentReadReplicaDBInstanceIdentifierList(&sv.ReadReplicaDBInstanceIdentifiers, nodeDecoder); err != nil { 13698 return err 13699 } 13700 13701 case strings.EqualFold("ReadReplicaSourceDBInstanceIdentifier", t.Name.Local): 13702 val, err := decoder.Value() 13703 if err != nil { 13704 return err 13705 } 13706 if val == nil { 13707 break 13708 } 13709 { 13710 xtv := string(val) 13711 sv.ReadReplicaSourceDBInstanceIdentifier = ptr.String(xtv) 13712 } 13713 13714 case strings.EqualFold("SecondaryAvailabilityZone", t.Name.Local): 13715 val, err := decoder.Value() 13716 if err != nil { 13717 return err 13718 } 13719 if val == nil { 13720 break 13721 } 13722 { 13723 xtv := string(val) 13724 sv.SecondaryAvailabilityZone = ptr.String(xtv) 13725 } 13726 13727 case strings.EqualFold("StatusInfos", t.Name.Local): 13728 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13729 if err := awsAwsquery_deserializeDocumentDBInstanceStatusInfoList(&sv.StatusInfos, nodeDecoder); err != nil { 13730 return err 13731 } 13732 13733 case strings.EqualFold("StorageEncrypted", t.Name.Local): 13734 val, err := decoder.Value() 13735 if err != nil { 13736 return err 13737 } 13738 if val == nil { 13739 break 13740 } 13741 { 13742 xtv, err := strconv.ParseBool(string(val)) 13743 if err != nil { 13744 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13745 } 13746 sv.StorageEncrypted = xtv 13747 } 13748 13749 case strings.EqualFold("StorageType", t.Name.Local): 13750 val, err := decoder.Value() 13751 if err != nil { 13752 return err 13753 } 13754 if val == nil { 13755 break 13756 } 13757 { 13758 xtv := string(val) 13759 sv.StorageType = ptr.String(xtv) 13760 } 13761 13762 case strings.EqualFold("TdeCredentialArn", t.Name.Local): 13763 val, err := decoder.Value() 13764 if err != nil { 13765 return err 13766 } 13767 if val == nil { 13768 break 13769 } 13770 { 13771 xtv := string(val) 13772 sv.TdeCredentialArn = ptr.String(xtv) 13773 } 13774 13775 case strings.EqualFold("Timezone", t.Name.Local): 13776 val, err := decoder.Value() 13777 if err != nil { 13778 return err 13779 } 13780 if val == nil { 13781 break 13782 } 13783 { 13784 xtv := string(val) 13785 sv.Timezone = ptr.String(xtv) 13786 } 13787 13788 case strings.EqualFold("VpcSecurityGroups", t.Name.Local): 13789 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13790 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipList(&sv.VpcSecurityGroups, nodeDecoder); err != nil { 13791 return err 13792 } 13793 13794 default: 13795 // Do nothing and ignore the unexpected tag element 13796 err = decoder.Decoder.Skip() 13797 if err != nil { 13798 return err 13799 } 13800 13801 } 13802 decoder = originalDecoder 13803 } 13804 *v = sv 13805 return nil 13806} 13807 13808func awsAwsquery_deserializeDocumentDBInstanceAlreadyExistsFault(v **types.DBInstanceAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 13809 if v == nil { 13810 return fmt.Errorf("unexpected nil of type %T", v) 13811 } 13812 var sv *types.DBInstanceAlreadyExistsFault 13813 if *v == nil { 13814 sv = &types.DBInstanceAlreadyExistsFault{} 13815 } else { 13816 sv = *v 13817 } 13818 13819 for { 13820 t, done, err := decoder.Token() 13821 if err != nil { 13822 return err 13823 } 13824 if done { 13825 break 13826 } 13827 originalDecoder := decoder 13828 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13829 switch { 13830 case strings.EqualFold("message", t.Name.Local): 13831 val, err := decoder.Value() 13832 if err != nil { 13833 return err 13834 } 13835 if val == nil { 13836 break 13837 } 13838 { 13839 xtv := string(val) 13840 sv.Message = ptr.String(xtv) 13841 } 13842 13843 default: 13844 // Do nothing and ignore the unexpected tag element 13845 err = decoder.Decoder.Skip() 13846 if err != nil { 13847 return err 13848 } 13849 13850 } 13851 decoder = originalDecoder 13852 } 13853 *v = sv 13854 return nil 13855} 13856 13857func awsAwsquery_deserializeDocumentDBInstanceList(v *[]types.DBInstance, decoder smithyxml.NodeDecoder) error { 13858 if v == nil { 13859 return fmt.Errorf("unexpected nil of type %T", v) 13860 } 13861 var sv []types.DBInstance 13862 if *v == nil { 13863 sv = make([]types.DBInstance, 0) 13864 } else { 13865 sv = *v 13866 } 13867 13868 originalDecoder := decoder 13869 for { 13870 t, done, err := decoder.Token() 13871 if err != nil { 13872 return err 13873 } 13874 if done { 13875 break 13876 } 13877 switch { 13878 case strings.EqualFold("DBInstance", t.Name.Local): 13879 var col types.DBInstance 13880 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13881 destAddr := &col 13882 if err := awsAwsquery_deserializeDocumentDBInstance(&destAddr, nodeDecoder); err != nil { 13883 return err 13884 } 13885 col = *destAddr 13886 sv = append(sv, col) 13887 13888 default: 13889 err = decoder.Decoder.Skip() 13890 if err != nil { 13891 return err 13892 } 13893 13894 } 13895 decoder = originalDecoder 13896 } 13897 *v = sv 13898 return nil 13899} 13900 13901func awsAwsquery_deserializeDocumentDBInstanceListUnwrapped(v *[]types.DBInstance, decoder smithyxml.NodeDecoder) error { 13902 var sv []types.DBInstance 13903 if *v == nil { 13904 sv = make([]types.DBInstance, 0) 13905 } else { 13906 sv = *v 13907 } 13908 13909 switch { 13910 default: 13911 var mv types.DBInstance 13912 t := decoder.StartEl 13913 _ = t 13914 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13915 destAddr := &mv 13916 if err := awsAwsquery_deserializeDocumentDBInstance(&destAddr, nodeDecoder); err != nil { 13917 return err 13918 } 13919 mv = *destAddr 13920 sv = append(sv, mv) 13921 } 13922 *v = sv 13923 return nil 13924} 13925func awsAwsquery_deserializeDocumentDBInstanceNotFoundFault(v **types.DBInstanceNotFoundFault, decoder smithyxml.NodeDecoder) error { 13926 if v == nil { 13927 return fmt.Errorf("unexpected nil of type %T", v) 13928 } 13929 var sv *types.DBInstanceNotFoundFault 13930 if *v == nil { 13931 sv = &types.DBInstanceNotFoundFault{} 13932 } else { 13933 sv = *v 13934 } 13935 13936 for { 13937 t, done, err := decoder.Token() 13938 if err != nil { 13939 return err 13940 } 13941 if done { 13942 break 13943 } 13944 originalDecoder := decoder 13945 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13946 switch { 13947 case strings.EqualFold("message", t.Name.Local): 13948 val, err := decoder.Value() 13949 if err != nil { 13950 return err 13951 } 13952 if val == nil { 13953 break 13954 } 13955 { 13956 xtv := string(val) 13957 sv.Message = ptr.String(xtv) 13958 } 13959 13960 default: 13961 // Do nothing and ignore the unexpected tag element 13962 err = decoder.Decoder.Skip() 13963 if err != nil { 13964 return err 13965 } 13966 13967 } 13968 decoder = originalDecoder 13969 } 13970 *v = sv 13971 return nil 13972} 13973 13974func awsAwsquery_deserializeDocumentDBInstanceStatusInfo(v **types.DBInstanceStatusInfo, decoder smithyxml.NodeDecoder) error { 13975 if v == nil { 13976 return fmt.Errorf("unexpected nil of type %T", v) 13977 } 13978 var sv *types.DBInstanceStatusInfo 13979 if *v == nil { 13980 sv = &types.DBInstanceStatusInfo{} 13981 } else { 13982 sv = *v 13983 } 13984 13985 for { 13986 t, done, err := decoder.Token() 13987 if err != nil { 13988 return err 13989 } 13990 if done { 13991 break 13992 } 13993 originalDecoder := decoder 13994 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13995 switch { 13996 case strings.EqualFold("Message", t.Name.Local): 13997 val, err := decoder.Value() 13998 if err != nil { 13999 return err 14000 } 14001 if val == nil { 14002 break 14003 } 14004 { 14005 xtv := string(val) 14006 sv.Message = ptr.String(xtv) 14007 } 14008 14009 case strings.EqualFold("Normal", t.Name.Local): 14010 val, err := decoder.Value() 14011 if err != nil { 14012 return err 14013 } 14014 if val == nil { 14015 break 14016 } 14017 { 14018 xtv, err := strconv.ParseBool(string(val)) 14019 if err != nil { 14020 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 14021 } 14022 sv.Normal = xtv 14023 } 14024 14025 case strings.EqualFold("Status", t.Name.Local): 14026 val, err := decoder.Value() 14027 if err != nil { 14028 return err 14029 } 14030 if val == nil { 14031 break 14032 } 14033 { 14034 xtv := string(val) 14035 sv.Status = ptr.String(xtv) 14036 } 14037 14038 case strings.EqualFold("StatusType", t.Name.Local): 14039 val, err := decoder.Value() 14040 if err != nil { 14041 return err 14042 } 14043 if val == nil { 14044 break 14045 } 14046 { 14047 xtv := string(val) 14048 sv.StatusType = ptr.String(xtv) 14049 } 14050 14051 default: 14052 // Do nothing and ignore the unexpected tag element 14053 err = decoder.Decoder.Skip() 14054 if err != nil { 14055 return err 14056 } 14057 14058 } 14059 decoder = originalDecoder 14060 } 14061 *v = sv 14062 return nil 14063} 14064 14065func awsAwsquery_deserializeDocumentDBInstanceStatusInfoList(v *[]types.DBInstanceStatusInfo, decoder smithyxml.NodeDecoder) error { 14066 if v == nil { 14067 return fmt.Errorf("unexpected nil of type %T", v) 14068 } 14069 var sv []types.DBInstanceStatusInfo 14070 if *v == nil { 14071 sv = make([]types.DBInstanceStatusInfo, 0) 14072 } else { 14073 sv = *v 14074 } 14075 14076 originalDecoder := decoder 14077 for { 14078 t, done, err := decoder.Token() 14079 if err != nil { 14080 return err 14081 } 14082 if done { 14083 break 14084 } 14085 switch { 14086 case strings.EqualFold("DBInstanceStatusInfo", t.Name.Local): 14087 var col types.DBInstanceStatusInfo 14088 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14089 destAddr := &col 14090 if err := awsAwsquery_deserializeDocumentDBInstanceStatusInfo(&destAddr, nodeDecoder); err != nil { 14091 return err 14092 } 14093 col = *destAddr 14094 sv = append(sv, col) 14095 14096 default: 14097 err = decoder.Decoder.Skip() 14098 if err != nil { 14099 return err 14100 } 14101 14102 } 14103 decoder = originalDecoder 14104 } 14105 *v = sv 14106 return nil 14107} 14108 14109func awsAwsquery_deserializeDocumentDBInstanceStatusInfoListUnwrapped(v *[]types.DBInstanceStatusInfo, decoder smithyxml.NodeDecoder) error { 14110 var sv []types.DBInstanceStatusInfo 14111 if *v == nil { 14112 sv = make([]types.DBInstanceStatusInfo, 0) 14113 } else { 14114 sv = *v 14115 } 14116 14117 switch { 14118 default: 14119 var mv types.DBInstanceStatusInfo 14120 t := decoder.StartEl 14121 _ = t 14122 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14123 destAddr := &mv 14124 if err := awsAwsquery_deserializeDocumentDBInstanceStatusInfo(&destAddr, nodeDecoder); err != nil { 14125 return err 14126 } 14127 mv = *destAddr 14128 sv = append(sv, mv) 14129 } 14130 *v = sv 14131 return nil 14132} 14133func awsAwsquery_deserializeDocumentDBParameterGroup(v **types.DBParameterGroup, decoder smithyxml.NodeDecoder) error { 14134 if v == nil { 14135 return fmt.Errorf("unexpected nil of type %T", v) 14136 } 14137 var sv *types.DBParameterGroup 14138 if *v == nil { 14139 sv = &types.DBParameterGroup{} 14140 } else { 14141 sv = *v 14142 } 14143 14144 for { 14145 t, done, err := decoder.Token() 14146 if err != nil { 14147 return err 14148 } 14149 if done { 14150 break 14151 } 14152 originalDecoder := decoder 14153 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14154 switch { 14155 case strings.EqualFold("DBParameterGroupArn", t.Name.Local): 14156 val, err := decoder.Value() 14157 if err != nil { 14158 return err 14159 } 14160 if val == nil { 14161 break 14162 } 14163 { 14164 xtv := string(val) 14165 sv.DBParameterGroupArn = ptr.String(xtv) 14166 } 14167 14168 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 14169 val, err := decoder.Value() 14170 if err != nil { 14171 return err 14172 } 14173 if val == nil { 14174 break 14175 } 14176 { 14177 xtv := string(val) 14178 sv.DBParameterGroupFamily = ptr.String(xtv) 14179 } 14180 14181 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 14182 val, err := decoder.Value() 14183 if err != nil { 14184 return err 14185 } 14186 if val == nil { 14187 break 14188 } 14189 { 14190 xtv := string(val) 14191 sv.DBParameterGroupName = ptr.String(xtv) 14192 } 14193 14194 case strings.EqualFold("Description", t.Name.Local): 14195 val, err := decoder.Value() 14196 if err != nil { 14197 return err 14198 } 14199 if val == nil { 14200 break 14201 } 14202 { 14203 xtv := string(val) 14204 sv.Description = ptr.String(xtv) 14205 } 14206 14207 default: 14208 // Do nothing and ignore the unexpected tag element 14209 err = decoder.Decoder.Skip() 14210 if err != nil { 14211 return err 14212 } 14213 14214 } 14215 decoder = originalDecoder 14216 } 14217 *v = sv 14218 return nil 14219} 14220 14221func awsAwsquery_deserializeDocumentDBParameterGroupAlreadyExistsFault(v **types.DBParameterGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 14222 if v == nil { 14223 return fmt.Errorf("unexpected nil of type %T", v) 14224 } 14225 var sv *types.DBParameterGroupAlreadyExistsFault 14226 if *v == nil { 14227 sv = &types.DBParameterGroupAlreadyExistsFault{} 14228 } else { 14229 sv = *v 14230 } 14231 14232 for { 14233 t, done, err := decoder.Token() 14234 if err != nil { 14235 return err 14236 } 14237 if done { 14238 break 14239 } 14240 originalDecoder := decoder 14241 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14242 switch { 14243 case strings.EqualFold("message", t.Name.Local): 14244 val, err := decoder.Value() 14245 if err != nil { 14246 return err 14247 } 14248 if val == nil { 14249 break 14250 } 14251 { 14252 xtv := string(val) 14253 sv.Message = ptr.String(xtv) 14254 } 14255 14256 default: 14257 // Do nothing and ignore the unexpected tag element 14258 err = decoder.Decoder.Skip() 14259 if err != nil { 14260 return err 14261 } 14262 14263 } 14264 decoder = originalDecoder 14265 } 14266 *v = sv 14267 return nil 14268} 14269 14270func awsAwsquery_deserializeDocumentDBParameterGroupList(v *[]types.DBParameterGroup, decoder smithyxml.NodeDecoder) error { 14271 if v == nil { 14272 return fmt.Errorf("unexpected nil of type %T", v) 14273 } 14274 var sv []types.DBParameterGroup 14275 if *v == nil { 14276 sv = make([]types.DBParameterGroup, 0) 14277 } else { 14278 sv = *v 14279 } 14280 14281 originalDecoder := decoder 14282 for { 14283 t, done, err := decoder.Token() 14284 if err != nil { 14285 return err 14286 } 14287 if done { 14288 break 14289 } 14290 switch { 14291 case strings.EqualFold("DBParameterGroup", t.Name.Local): 14292 var col types.DBParameterGroup 14293 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14294 destAddr := &col 14295 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&destAddr, nodeDecoder); err != nil { 14296 return err 14297 } 14298 col = *destAddr 14299 sv = append(sv, col) 14300 14301 default: 14302 err = decoder.Decoder.Skip() 14303 if err != nil { 14304 return err 14305 } 14306 14307 } 14308 decoder = originalDecoder 14309 } 14310 *v = sv 14311 return nil 14312} 14313 14314func awsAwsquery_deserializeDocumentDBParameterGroupListUnwrapped(v *[]types.DBParameterGroup, decoder smithyxml.NodeDecoder) error { 14315 var sv []types.DBParameterGroup 14316 if *v == nil { 14317 sv = make([]types.DBParameterGroup, 0) 14318 } else { 14319 sv = *v 14320 } 14321 14322 switch { 14323 default: 14324 var mv types.DBParameterGroup 14325 t := decoder.StartEl 14326 _ = t 14327 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14328 destAddr := &mv 14329 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&destAddr, nodeDecoder); err != nil { 14330 return err 14331 } 14332 mv = *destAddr 14333 sv = append(sv, mv) 14334 } 14335 *v = sv 14336 return nil 14337} 14338func awsAwsquery_deserializeDocumentDBParameterGroupNotFoundFault(v **types.DBParameterGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 14339 if v == nil { 14340 return fmt.Errorf("unexpected nil of type %T", v) 14341 } 14342 var sv *types.DBParameterGroupNotFoundFault 14343 if *v == nil { 14344 sv = &types.DBParameterGroupNotFoundFault{} 14345 } else { 14346 sv = *v 14347 } 14348 14349 for { 14350 t, done, err := decoder.Token() 14351 if err != nil { 14352 return err 14353 } 14354 if done { 14355 break 14356 } 14357 originalDecoder := decoder 14358 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14359 switch { 14360 case strings.EqualFold("message", t.Name.Local): 14361 val, err := decoder.Value() 14362 if err != nil { 14363 return err 14364 } 14365 if val == nil { 14366 break 14367 } 14368 { 14369 xtv := string(val) 14370 sv.Message = ptr.String(xtv) 14371 } 14372 14373 default: 14374 // Do nothing and ignore the unexpected tag element 14375 err = decoder.Decoder.Skip() 14376 if err != nil { 14377 return err 14378 } 14379 14380 } 14381 decoder = originalDecoder 14382 } 14383 *v = sv 14384 return nil 14385} 14386 14387func awsAwsquery_deserializeDocumentDBParameterGroupQuotaExceededFault(v **types.DBParameterGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 14388 if v == nil { 14389 return fmt.Errorf("unexpected nil of type %T", v) 14390 } 14391 var sv *types.DBParameterGroupQuotaExceededFault 14392 if *v == nil { 14393 sv = &types.DBParameterGroupQuotaExceededFault{} 14394 } else { 14395 sv = *v 14396 } 14397 14398 for { 14399 t, done, err := decoder.Token() 14400 if err != nil { 14401 return err 14402 } 14403 if done { 14404 break 14405 } 14406 originalDecoder := decoder 14407 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14408 switch { 14409 case strings.EqualFold("message", t.Name.Local): 14410 val, err := decoder.Value() 14411 if err != nil { 14412 return err 14413 } 14414 if val == nil { 14415 break 14416 } 14417 { 14418 xtv := string(val) 14419 sv.Message = ptr.String(xtv) 14420 } 14421 14422 default: 14423 // Do nothing and ignore the unexpected tag element 14424 err = decoder.Decoder.Skip() 14425 if err != nil { 14426 return err 14427 } 14428 14429 } 14430 decoder = originalDecoder 14431 } 14432 *v = sv 14433 return nil 14434} 14435 14436func awsAwsquery_deserializeDocumentDBParameterGroupStatus(v **types.DBParameterGroupStatus, decoder smithyxml.NodeDecoder) error { 14437 if v == nil { 14438 return fmt.Errorf("unexpected nil of type %T", v) 14439 } 14440 var sv *types.DBParameterGroupStatus 14441 if *v == nil { 14442 sv = &types.DBParameterGroupStatus{} 14443 } else { 14444 sv = *v 14445 } 14446 14447 for { 14448 t, done, err := decoder.Token() 14449 if err != nil { 14450 return err 14451 } 14452 if done { 14453 break 14454 } 14455 originalDecoder := decoder 14456 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14457 switch { 14458 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 14459 val, err := decoder.Value() 14460 if err != nil { 14461 return err 14462 } 14463 if val == nil { 14464 break 14465 } 14466 { 14467 xtv := string(val) 14468 sv.DBParameterGroupName = ptr.String(xtv) 14469 } 14470 14471 case strings.EqualFold("ParameterApplyStatus", t.Name.Local): 14472 val, err := decoder.Value() 14473 if err != nil { 14474 return err 14475 } 14476 if val == nil { 14477 break 14478 } 14479 { 14480 xtv := string(val) 14481 sv.ParameterApplyStatus = ptr.String(xtv) 14482 } 14483 14484 default: 14485 // Do nothing and ignore the unexpected tag element 14486 err = decoder.Decoder.Skip() 14487 if err != nil { 14488 return err 14489 } 14490 14491 } 14492 decoder = originalDecoder 14493 } 14494 *v = sv 14495 return nil 14496} 14497 14498func awsAwsquery_deserializeDocumentDBParameterGroupStatusList(v *[]types.DBParameterGroupStatus, decoder smithyxml.NodeDecoder) error { 14499 if v == nil { 14500 return fmt.Errorf("unexpected nil of type %T", v) 14501 } 14502 var sv []types.DBParameterGroupStatus 14503 if *v == nil { 14504 sv = make([]types.DBParameterGroupStatus, 0) 14505 } else { 14506 sv = *v 14507 } 14508 14509 originalDecoder := decoder 14510 for { 14511 t, done, err := decoder.Token() 14512 if err != nil { 14513 return err 14514 } 14515 if done { 14516 break 14517 } 14518 switch { 14519 case strings.EqualFold("DBParameterGroup", t.Name.Local): 14520 var col types.DBParameterGroupStatus 14521 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14522 destAddr := &col 14523 if err := awsAwsquery_deserializeDocumentDBParameterGroupStatus(&destAddr, nodeDecoder); err != nil { 14524 return err 14525 } 14526 col = *destAddr 14527 sv = append(sv, col) 14528 14529 default: 14530 err = decoder.Decoder.Skip() 14531 if err != nil { 14532 return err 14533 } 14534 14535 } 14536 decoder = originalDecoder 14537 } 14538 *v = sv 14539 return nil 14540} 14541 14542func awsAwsquery_deserializeDocumentDBParameterGroupStatusListUnwrapped(v *[]types.DBParameterGroupStatus, decoder smithyxml.NodeDecoder) error { 14543 var sv []types.DBParameterGroupStatus 14544 if *v == nil { 14545 sv = make([]types.DBParameterGroupStatus, 0) 14546 } else { 14547 sv = *v 14548 } 14549 14550 switch { 14551 default: 14552 var mv types.DBParameterGroupStatus 14553 t := decoder.StartEl 14554 _ = t 14555 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14556 destAddr := &mv 14557 if err := awsAwsquery_deserializeDocumentDBParameterGroupStatus(&destAddr, nodeDecoder); err != nil { 14558 return err 14559 } 14560 mv = *destAddr 14561 sv = append(sv, mv) 14562 } 14563 *v = sv 14564 return nil 14565} 14566func awsAwsquery_deserializeDocumentDBSecurityGroupMembership(v **types.DBSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 14567 if v == nil { 14568 return fmt.Errorf("unexpected nil of type %T", v) 14569 } 14570 var sv *types.DBSecurityGroupMembership 14571 if *v == nil { 14572 sv = &types.DBSecurityGroupMembership{} 14573 } else { 14574 sv = *v 14575 } 14576 14577 for { 14578 t, done, err := decoder.Token() 14579 if err != nil { 14580 return err 14581 } 14582 if done { 14583 break 14584 } 14585 originalDecoder := decoder 14586 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14587 switch { 14588 case strings.EqualFold("DBSecurityGroupName", t.Name.Local): 14589 val, err := decoder.Value() 14590 if err != nil { 14591 return err 14592 } 14593 if val == nil { 14594 break 14595 } 14596 { 14597 xtv := string(val) 14598 sv.DBSecurityGroupName = ptr.String(xtv) 14599 } 14600 14601 case strings.EqualFold("Status", t.Name.Local): 14602 val, err := decoder.Value() 14603 if err != nil { 14604 return err 14605 } 14606 if val == nil { 14607 break 14608 } 14609 { 14610 xtv := string(val) 14611 sv.Status = ptr.String(xtv) 14612 } 14613 14614 default: 14615 // Do nothing and ignore the unexpected tag element 14616 err = decoder.Decoder.Skip() 14617 if err != nil { 14618 return err 14619 } 14620 14621 } 14622 decoder = originalDecoder 14623 } 14624 *v = sv 14625 return nil 14626} 14627 14628func awsAwsquery_deserializeDocumentDBSecurityGroupMembershipList(v *[]types.DBSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 14629 if v == nil { 14630 return fmt.Errorf("unexpected nil of type %T", v) 14631 } 14632 var sv []types.DBSecurityGroupMembership 14633 if *v == nil { 14634 sv = make([]types.DBSecurityGroupMembership, 0) 14635 } else { 14636 sv = *v 14637 } 14638 14639 originalDecoder := decoder 14640 for { 14641 t, done, err := decoder.Token() 14642 if err != nil { 14643 return err 14644 } 14645 if done { 14646 break 14647 } 14648 switch { 14649 case strings.EqualFold("DBSecurityGroup", t.Name.Local): 14650 var col types.DBSecurityGroupMembership 14651 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14652 destAddr := &col 14653 if err := awsAwsquery_deserializeDocumentDBSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 14654 return err 14655 } 14656 col = *destAddr 14657 sv = append(sv, col) 14658 14659 default: 14660 err = decoder.Decoder.Skip() 14661 if err != nil { 14662 return err 14663 } 14664 14665 } 14666 decoder = originalDecoder 14667 } 14668 *v = sv 14669 return nil 14670} 14671 14672func awsAwsquery_deserializeDocumentDBSecurityGroupMembershipListUnwrapped(v *[]types.DBSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 14673 var sv []types.DBSecurityGroupMembership 14674 if *v == nil { 14675 sv = make([]types.DBSecurityGroupMembership, 0) 14676 } else { 14677 sv = *v 14678 } 14679 14680 switch { 14681 default: 14682 var mv types.DBSecurityGroupMembership 14683 t := decoder.StartEl 14684 _ = t 14685 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14686 destAddr := &mv 14687 if err := awsAwsquery_deserializeDocumentDBSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 14688 return err 14689 } 14690 mv = *destAddr 14691 sv = append(sv, mv) 14692 } 14693 *v = sv 14694 return nil 14695} 14696func awsAwsquery_deserializeDocumentDBSecurityGroupNotFoundFault(v **types.DBSecurityGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 14697 if v == nil { 14698 return fmt.Errorf("unexpected nil of type %T", v) 14699 } 14700 var sv *types.DBSecurityGroupNotFoundFault 14701 if *v == nil { 14702 sv = &types.DBSecurityGroupNotFoundFault{} 14703 } else { 14704 sv = *v 14705 } 14706 14707 for { 14708 t, done, err := decoder.Token() 14709 if err != nil { 14710 return err 14711 } 14712 if done { 14713 break 14714 } 14715 originalDecoder := decoder 14716 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14717 switch { 14718 case strings.EqualFold("message", t.Name.Local): 14719 val, err := decoder.Value() 14720 if err != nil { 14721 return err 14722 } 14723 if val == nil { 14724 break 14725 } 14726 { 14727 xtv := string(val) 14728 sv.Message = ptr.String(xtv) 14729 } 14730 14731 default: 14732 // Do nothing and ignore the unexpected tag element 14733 err = decoder.Decoder.Skip() 14734 if err != nil { 14735 return err 14736 } 14737 14738 } 14739 decoder = originalDecoder 14740 } 14741 *v = sv 14742 return nil 14743} 14744 14745func awsAwsquery_deserializeDocumentDBSnapshotAlreadyExistsFault(v **types.DBSnapshotAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 14746 if v == nil { 14747 return fmt.Errorf("unexpected nil of type %T", v) 14748 } 14749 var sv *types.DBSnapshotAlreadyExistsFault 14750 if *v == nil { 14751 sv = &types.DBSnapshotAlreadyExistsFault{} 14752 } else { 14753 sv = *v 14754 } 14755 14756 for { 14757 t, done, err := decoder.Token() 14758 if err != nil { 14759 return err 14760 } 14761 if done { 14762 break 14763 } 14764 originalDecoder := decoder 14765 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14766 switch { 14767 case strings.EqualFold("message", t.Name.Local): 14768 val, err := decoder.Value() 14769 if err != nil { 14770 return err 14771 } 14772 if val == nil { 14773 break 14774 } 14775 { 14776 xtv := string(val) 14777 sv.Message = ptr.String(xtv) 14778 } 14779 14780 default: 14781 // Do nothing and ignore the unexpected tag element 14782 err = decoder.Decoder.Skip() 14783 if err != nil { 14784 return err 14785 } 14786 14787 } 14788 decoder = originalDecoder 14789 } 14790 *v = sv 14791 return nil 14792} 14793 14794func awsAwsquery_deserializeDocumentDBSnapshotNotFoundFault(v **types.DBSnapshotNotFoundFault, decoder smithyxml.NodeDecoder) error { 14795 if v == nil { 14796 return fmt.Errorf("unexpected nil of type %T", v) 14797 } 14798 var sv *types.DBSnapshotNotFoundFault 14799 if *v == nil { 14800 sv = &types.DBSnapshotNotFoundFault{} 14801 } else { 14802 sv = *v 14803 } 14804 14805 for { 14806 t, done, err := decoder.Token() 14807 if err != nil { 14808 return err 14809 } 14810 if done { 14811 break 14812 } 14813 originalDecoder := decoder 14814 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14815 switch { 14816 case strings.EqualFold("message", t.Name.Local): 14817 val, err := decoder.Value() 14818 if err != nil { 14819 return err 14820 } 14821 if val == nil { 14822 break 14823 } 14824 { 14825 xtv := string(val) 14826 sv.Message = ptr.String(xtv) 14827 } 14828 14829 default: 14830 // Do nothing and ignore the unexpected tag element 14831 err = decoder.Decoder.Skip() 14832 if err != nil { 14833 return err 14834 } 14835 14836 } 14837 decoder = originalDecoder 14838 } 14839 *v = sv 14840 return nil 14841} 14842 14843func awsAwsquery_deserializeDocumentDBSubnetGroup(v **types.DBSubnetGroup, decoder smithyxml.NodeDecoder) error { 14844 if v == nil { 14845 return fmt.Errorf("unexpected nil of type %T", v) 14846 } 14847 var sv *types.DBSubnetGroup 14848 if *v == nil { 14849 sv = &types.DBSubnetGroup{} 14850 } else { 14851 sv = *v 14852 } 14853 14854 for { 14855 t, done, err := decoder.Token() 14856 if err != nil { 14857 return err 14858 } 14859 if done { 14860 break 14861 } 14862 originalDecoder := decoder 14863 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14864 switch { 14865 case strings.EqualFold("DBSubnetGroupArn", t.Name.Local): 14866 val, err := decoder.Value() 14867 if err != nil { 14868 return err 14869 } 14870 if val == nil { 14871 break 14872 } 14873 { 14874 xtv := string(val) 14875 sv.DBSubnetGroupArn = ptr.String(xtv) 14876 } 14877 14878 case strings.EqualFold("DBSubnetGroupDescription", t.Name.Local): 14879 val, err := decoder.Value() 14880 if err != nil { 14881 return err 14882 } 14883 if val == nil { 14884 break 14885 } 14886 { 14887 xtv := string(val) 14888 sv.DBSubnetGroupDescription = ptr.String(xtv) 14889 } 14890 14891 case strings.EqualFold("DBSubnetGroupName", t.Name.Local): 14892 val, err := decoder.Value() 14893 if err != nil { 14894 return err 14895 } 14896 if val == nil { 14897 break 14898 } 14899 { 14900 xtv := string(val) 14901 sv.DBSubnetGroupName = ptr.String(xtv) 14902 } 14903 14904 case strings.EqualFold("SubnetGroupStatus", t.Name.Local): 14905 val, err := decoder.Value() 14906 if err != nil { 14907 return err 14908 } 14909 if val == nil { 14910 break 14911 } 14912 { 14913 xtv := string(val) 14914 sv.SubnetGroupStatus = ptr.String(xtv) 14915 } 14916 14917 case strings.EqualFold("Subnets", t.Name.Local): 14918 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14919 if err := awsAwsquery_deserializeDocumentSubnetList(&sv.Subnets, nodeDecoder); err != nil { 14920 return err 14921 } 14922 14923 case strings.EqualFold("VpcId", t.Name.Local): 14924 val, err := decoder.Value() 14925 if err != nil { 14926 return err 14927 } 14928 if val == nil { 14929 break 14930 } 14931 { 14932 xtv := string(val) 14933 sv.VpcId = ptr.String(xtv) 14934 } 14935 14936 default: 14937 // Do nothing and ignore the unexpected tag element 14938 err = decoder.Decoder.Skip() 14939 if err != nil { 14940 return err 14941 } 14942 14943 } 14944 decoder = originalDecoder 14945 } 14946 *v = sv 14947 return nil 14948} 14949 14950func awsAwsquery_deserializeDocumentDBSubnetGroupAlreadyExistsFault(v **types.DBSubnetGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 14951 if v == nil { 14952 return fmt.Errorf("unexpected nil of type %T", v) 14953 } 14954 var sv *types.DBSubnetGroupAlreadyExistsFault 14955 if *v == nil { 14956 sv = &types.DBSubnetGroupAlreadyExistsFault{} 14957 } else { 14958 sv = *v 14959 } 14960 14961 for { 14962 t, done, err := decoder.Token() 14963 if err != nil { 14964 return err 14965 } 14966 if done { 14967 break 14968 } 14969 originalDecoder := decoder 14970 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14971 switch { 14972 case strings.EqualFold("message", t.Name.Local): 14973 val, err := decoder.Value() 14974 if err != nil { 14975 return err 14976 } 14977 if val == nil { 14978 break 14979 } 14980 { 14981 xtv := string(val) 14982 sv.Message = ptr.String(xtv) 14983 } 14984 14985 default: 14986 // Do nothing and ignore the unexpected tag element 14987 err = decoder.Decoder.Skip() 14988 if err != nil { 14989 return err 14990 } 14991 14992 } 14993 decoder = originalDecoder 14994 } 14995 *v = sv 14996 return nil 14997} 14998 14999func awsAwsquery_deserializeDocumentDBSubnetGroupDoesNotCoverEnoughAZs(v **types.DBSubnetGroupDoesNotCoverEnoughAZs, decoder smithyxml.NodeDecoder) error { 15000 if v == nil { 15001 return fmt.Errorf("unexpected nil of type %T", v) 15002 } 15003 var sv *types.DBSubnetGroupDoesNotCoverEnoughAZs 15004 if *v == nil { 15005 sv = &types.DBSubnetGroupDoesNotCoverEnoughAZs{} 15006 } else { 15007 sv = *v 15008 } 15009 15010 for { 15011 t, done, err := decoder.Token() 15012 if err != nil { 15013 return err 15014 } 15015 if done { 15016 break 15017 } 15018 originalDecoder := decoder 15019 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15020 switch { 15021 case strings.EqualFold("message", t.Name.Local): 15022 val, err := decoder.Value() 15023 if err != nil { 15024 return err 15025 } 15026 if val == nil { 15027 break 15028 } 15029 { 15030 xtv := string(val) 15031 sv.Message = ptr.String(xtv) 15032 } 15033 15034 default: 15035 // Do nothing and ignore the unexpected tag element 15036 err = decoder.Decoder.Skip() 15037 if err != nil { 15038 return err 15039 } 15040 15041 } 15042 decoder = originalDecoder 15043 } 15044 *v = sv 15045 return nil 15046} 15047 15048func awsAwsquery_deserializeDocumentDBSubnetGroupNotFoundFault(v **types.DBSubnetGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 15049 if v == nil { 15050 return fmt.Errorf("unexpected nil of type %T", v) 15051 } 15052 var sv *types.DBSubnetGroupNotFoundFault 15053 if *v == nil { 15054 sv = &types.DBSubnetGroupNotFoundFault{} 15055 } else { 15056 sv = *v 15057 } 15058 15059 for { 15060 t, done, err := decoder.Token() 15061 if err != nil { 15062 return err 15063 } 15064 if done { 15065 break 15066 } 15067 originalDecoder := decoder 15068 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15069 switch { 15070 case strings.EqualFold("message", t.Name.Local): 15071 val, err := decoder.Value() 15072 if err != nil { 15073 return err 15074 } 15075 if val == nil { 15076 break 15077 } 15078 { 15079 xtv := string(val) 15080 sv.Message = ptr.String(xtv) 15081 } 15082 15083 default: 15084 // Do nothing and ignore the unexpected tag element 15085 err = decoder.Decoder.Skip() 15086 if err != nil { 15087 return err 15088 } 15089 15090 } 15091 decoder = originalDecoder 15092 } 15093 *v = sv 15094 return nil 15095} 15096 15097func awsAwsquery_deserializeDocumentDBSubnetGroupQuotaExceededFault(v **types.DBSubnetGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 15098 if v == nil { 15099 return fmt.Errorf("unexpected nil of type %T", v) 15100 } 15101 var sv *types.DBSubnetGroupQuotaExceededFault 15102 if *v == nil { 15103 sv = &types.DBSubnetGroupQuotaExceededFault{} 15104 } else { 15105 sv = *v 15106 } 15107 15108 for { 15109 t, done, err := decoder.Token() 15110 if err != nil { 15111 return err 15112 } 15113 if done { 15114 break 15115 } 15116 originalDecoder := decoder 15117 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15118 switch { 15119 case strings.EqualFold("message", t.Name.Local): 15120 val, err := decoder.Value() 15121 if err != nil { 15122 return err 15123 } 15124 if val == nil { 15125 break 15126 } 15127 { 15128 xtv := string(val) 15129 sv.Message = ptr.String(xtv) 15130 } 15131 15132 default: 15133 // Do nothing and ignore the unexpected tag element 15134 err = decoder.Decoder.Skip() 15135 if err != nil { 15136 return err 15137 } 15138 15139 } 15140 decoder = originalDecoder 15141 } 15142 *v = sv 15143 return nil 15144} 15145 15146func awsAwsquery_deserializeDocumentDBSubnetGroups(v *[]types.DBSubnetGroup, decoder smithyxml.NodeDecoder) error { 15147 if v == nil { 15148 return fmt.Errorf("unexpected nil of type %T", v) 15149 } 15150 var sv []types.DBSubnetGroup 15151 if *v == nil { 15152 sv = make([]types.DBSubnetGroup, 0) 15153 } else { 15154 sv = *v 15155 } 15156 15157 originalDecoder := decoder 15158 for { 15159 t, done, err := decoder.Token() 15160 if err != nil { 15161 return err 15162 } 15163 if done { 15164 break 15165 } 15166 switch { 15167 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 15168 var col types.DBSubnetGroup 15169 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15170 destAddr := &col 15171 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&destAddr, nodeDecoder); err != nil { 15172 return err 15173 } 15174 col = *destAddr 15175 sv = append(sv, col) 15176 15177 default: 15178 err = decoder.Decoder.Skip() 15179 if err != nil { 15180 return err 15181 } 15182 15183 } 15184 decoder = originalDecoder 15185 } 15186 *v = sv 15187 return nil 15188} 15189 15190func awsAwsquery_deserializeDocumentDBSubnetGroupsUnwrapped(v *[]types.DBSubnetGroup, decoder smithyxml.NodeDecoder) error { 15191 var sv []types.DBSubnetGroup 15192 if *v == nil { 15193 sv = make([]types.DBSubnetGroup, 0) 15194 } else { 15195 sv = *v 15196 } 15197 15198 switch { 15199 default: 15200 var mv types.DBSubnetGroup 15201 t := decoder.StartEl 15202 _ = t 15203 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15204 destAddr := &mv 15205 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&destAddr, nodeDecoder); err != nil { 15206 return err 15207 } 15208 mv = *destAddr 15209 sv = append(sv, mv) 15210 } 15211 *v = sv 15212 return nil 15213} 15214func awsAwsquery_deserializeDocumentDBSubnetQuotaExceededFault(v **types.DBSubnetQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 15215 if v == nil { 15216 return fmt.Errorf("unexpected nil of type %T", v) 15217 } 15218 var sv *types.DBSubnetQuotaExceededFault 15219 if *v == nil { 15220 sv = &types.DBSubnetQuotaExceededFault{} 15221 } else { 15222 sv = *v 15223 } 15224 15225 for { 15226 t, done, err := decoder.Token() 15227 if err != nil { 15228 return err 15229 } 15230 if done { 15231 break 15232 } 15233 originalDecoder := decoder 15234 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15235 switch { 15236 case strings.EqualFold("message", t.Name.Local): 15237 val, err := decoder.Value() 15238 if err != nil { 15239 return err 15240 } 15241 if val == nil { 15242 break 15243 } 15244 { 15245 xtv := string(val) 15246 sv.Message = ptr.String(xtv) 15247 } 15248 15249 default: 15250 // Do nothing and ignore the unexpected tag element 15251 err = decoder.Decoder.Skip() 15252 if err != nil { 15253 return err 15254 } 15255 15256 } 15257 decoder = originalDecoder 15258 } 15259 *v = sv 15260 return nil 15261} 15262 15263func awsAwsquery_deserializeDocumentDBUpgradeDependencyFailureFault(v **types.DBUpgradeDependencyFailureFault, decoder smithyxml.NodeDecoder) error { 15264 if v == nil { 15265 return fmt.Errorf("unexpected nil of type %T", v) 15266 } 15267 var sv *types.DBUpgradeDependencyFailureFault 15268 if *v == nil { 15269 sv = &types.DBUpgradeDependencyFailureFault{} 15270 } else { 15271 sv = *v 15272 } 15273 15274 for { 15275 t, done, err := decoder.Token() 15276 if err != nil { 15277 return err 15278 } 15279 if done { 15280 break 15281 } 15282 originalDecoder := decoder 15283 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15284 switch { 15285 case strings.EqualFold("message", t.Name.Local): 15286 val, err := decoder.Value() 15287 if err != nil { 15288 return err 15289 } 15290 if val == nil { 15291 break 15292 } 15293 { 15294 xtv := string(val) 15295 sv.Message = ptr.String(xtv) 15296 } 15297 15298 default: 15299 // Do nothing and ignore the unexpected tag element 15300 err = decoder.Decoder.Skip() 15301 if err != nil { 15302 return err 15303 } 15304 15305 } 15306 decoder = originalDecoder 15307 } 15308 *v = sv 15309 return nil 15310} 15311 15312func awsAwsquery_deserializeDocumentDomainMembership(v **types.DomainMembership, decoder smithyxml.NodeDecoder) error { 15313 if v == nil { 15314 return fmt.Errorf("unexpected nil of type %T", v) 15315 } 15316 var sv *types.DomainMembership 15317 if *v == nil { 15318 sv = &types.DomainMembership{} 15319 } else { 15320 sv = *v 15321 } 15322 15323 for { 15324 t, done, err := decoder.Token() 15325 if err != nil { 15326 return err 15327 } 15328 if done { 15329 break 15330 } 15331 originalDecoder := decoder 15332 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15333 switch { 15334 case strings.EqualFold("Domain", t.Name.Local): 15335 val, err := decoder.Value() 15336 if err != nil { 15337 return err 15338 } 15339 if val == nil { 15340 break 15341 } 15342 { 15343 xtv := string(val) 15344 sv.Domain = ptr.String(xtv) 15345 } 15346 15347 case strings.EqualFold("FQDN", t.Name.Local): 15348 val, err := decoder.Value() 15349 if err != nil { 15350 return err 15351 } 15352 if val == nil { 15353 break 15354 } 15355 { 15356 xtv := string(val) 15357 sv.FQDN = ptr.String(xtv) 15358 } 15359 15360 case strings.EqualFold("IAMRoleName", t.Name.Local): 15361 val, err := decoder.Value() 15362 if err != nil { 15363 return err 15364 } 15365 if val == nil { 15366 break 15367 } 15368 { 15369 xtv := string(val) 15370 sv.IAMRoleName = ptr.String(xtv) 15371 } 15372 15373 case strings.EqualFold("Status", t.Name.Local): 15374 val, err := decoder.Value() 15375 if err != nil { 15376 return err 15377 } 15378 if val == nil { 15379 break 15380 } 15381 { 15382 xtv := string(val) 15383 sv.Status = ptr.String(xtv) 15384 } 15385 15386 default: 15387 // Do nothing and ignore the unexpected tag element 15388 err = decoder.Decoder.Skip() 15389 if err != nil { 15390 return err 15391 } 15392 15393 } 15394 decoder = originalDecoder 15395 } 15396 *v = sv 15397 return nil 15398} 15399 15400func awsAwsquery_deserializeDocumentDomainMembershipList(v *[]types.DomainMembership, decoder smithyxml.NodeDecoder) error { 15401 if v == nil { 15402 return fmt.Errorf("unexpected nil of type %T", v) 15403 } 15404 var sv []types.DomainMembership 15405 if *v == nil { 15406 sv = make([]types.DomainMembership, 0) 15407 } else { 15408 sv = *v 15409 } 15410 15411 originalDecoder := decoder 15412 for { 15413 t, done, err := decoder.Token() 15414 if err != nil { 15415 return err 15416 } 15417 if done { 15418 break 15419 } 15420 switch { 15421 case strings.EqualFold("DomainMembership", t.Name.Local): 15422 var col types.DomainMembership 15423 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15424 destAddr := &col 15425 if err := awsAwsquery_deserializeDocumentDomainMembership(&destAddr, nodeDecoder); err != nil { 15426 return err 15427 } 15428 col = *destAddr 15429 sv = append(sv, col) 15430 15431 default: 15432 err = decoder.Decoder.Skip() 15433 if err != nil { 15434 return err 15435 } 15436 15437 } 15438 decoder = originalDecoder 15439 } 15440 *v = sv 15441 return nil 15442} 15443 15444func awsAwsquery_deserializeDocumentDomainMembershipListUnwrapped(v *[]types.DomainMembership, decoder smithyxml.NodeDecoder) error { 15445 var sv []types.DomainMembership 15446 if *v == nil { 15447 sv = make([]types.DomainMembership, 0) 15448 } else { 15449 sv = *v 15450 } 15451 15452 switch { 15453 default: 15454 var mv types.DomainMembership 15455 t := decoder.StartEl 15456 _ = t 15457 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15458 destAddr := &mv 15459 if err := awsAwsquery_deserializeDocumentDomainMembership(&destAddr, nodeDecoder); err != nil { 15460 return err 15461 } 15462 mv = *destAddr 15463 sv = append(sv, mv) 15464 } 15465 *v = sv 15466 return nil 15467} 15468func awsAwsquery_deserializeDocumentDomainNotFoundFault(v **types.DomainNotFoundFault, decoder smithyxml.NodeDecoder) error { 15469 if v == nil { 15470 return fmt.Errorf("unexpected nil of type %T", v) 15471 } 15472 var sv *types.DomainNotFoundFault 15473 if *v == nil { 15474 sv = &types.DomainNotFoundFault{} 15475 } else { 15476 sv = *v 15477 } 15478 15479 for { 15480 t, done, err := decoder.Token() 15481 if err != nil { 15482 return err 15483 } 15484 if done { 15485 break 15486 } 15487 originalDecoder := decoder 15488 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15489 switch { 15490 case strings.EqualFold("message", t.Name.Local): 15491 val, err := decoder.Value() 15492 if err != nil { 15493 return err 15494 } 15495 if val == nil { 15496 break 15497 } 15498 { 15499 xtv := string(val) 15500 sv.Message = ptr.String(xtv) 15501 } 15502 15503 default: 15504 // Do nothing and ignore the unexpected tag element 15505 err = decoder.Decoder.Skip() 15506 if err != nil { 15507 return err 15508 } 15509 15510 } 15511 decoder = originalDecoder 15512 } 15513 *v = sv 15514 return nil 15515} 15516 15517func awsAwsquery_deserializeDocumentDoubleRange(v **types.DoubleRange, decoder smithyxml.NodeDecoder) error { 15518 if v == nil { 15519 return fmt.Errorf("unexpected nil of type %T", v) 15520 } 15521 var sv *types.DoubleRange 15522 if *v == nil { 15523 sv = &types.DoubleRange{} 15524 } else { 15525 sv = *v 15526 } 15527 15528 for { 15529 t, done, err := decoder.Token() 15530 if err != nil { 15531 return err 15532 } 15533 if done { 15534 break 15535 } 15536 originalDecoder := decoder 15537 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15538 switch { 15539 case strings.EqualFold("From", t.Name.Local): 15540 val, err := decoder.Value() 15541 if err != nil { 15542 return err 15543 } 15544 if val == nil { 15545 break 15546 } 15547 { 15548 xtv := string(val) 15549 f64, err := strconv.ParseFloat(xtv, 64) 15550 if err != nil { 15551 return err 15552 } 15553 sv.From = f64 15554 } 15555 15556 case strings.EqualFold("To", t.Name.Local): 15557 val, err := decoder.Value() 15558 if err != nil { 15559 return err 15560 } 15561 if val == nil { 15562 break 15563 } 15564 { 15565 xtv := string(val) 15566 f64, err := strconv.ParseFloat(xtv, 64) 15567 if err != nil { 15568 return err 15569 } 15570 sv.To = f64 15571 } 15572 15573 default: 15574 // Do nothing and ignore the unexpected tag element 15575 err = decoder.Decoder.Skip() 15576 if err != nil { 15577 return err 15578 } 15579 15580 } 15581 decoder = originalDecoder 15582 } 15583 *v = sv 15584 return nil 15585} 15586 15587func awsAwsquery_deserializeDocumentDoubleRangeList(v *[]types.DoubleRange, decoder smithyxml.NodeDecoder) error { 15588 if v == nil { 15589 return fmt.Errorf("unexpected nil of type %T", v) 15590 } 15591 var sv []types.DoubleRange 15592 if *v == nil { 15593 sv = make([]types.DoubleRange, 0) 15594 } else { 15595 sv = *v 15596 } 15597 15598 originalDecoder := decoder 15599 for { 15600 t, done, err := decoder.Token() 15601 if err != nil { 15602 return err 15603 } 15604 if done { 15605 break 15606 } 15607 switch { 15608 case strings.EqualFold("DoubleRange", t.Name.Local): 15609 var col types.DoubleRange 15610 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15611 destAddr := &col 15612 if err := awsAwsquery_deserializeDocumentDoubleRange(&destAddr, nodeDecoder); err != nil { 15613 return err 15614 } 15615 col = *destAddr 15616 sv = append(sv, col) 15617 15618 default: 15619 err = decoder.Decoder.Skip() 15620 if err != nil { 15621 return err 15622 } 15623 15624 } 15625 decoder = originalDecoder 15626 } 15627 *v = sv 15628 return nil 15629} 15630 15631func awsAwsquery_deserializeDocumentDoubleRangeListUnwrapped(v *[]types.DoubleRange, decoder smithyxml.NodeDecoder) error { 15632 var sv []types.DoubleRange 15633 if *v == nil { 15634 sv = make([]types.DoubleRange, 0) 15635 } else { 15636 sv = *v 15637 } 15638 15639 switch { 15640 default: 15641 var mv types.DoubleRange 15642 t := decoder.StartEl 15643 _ = t 15644 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15645 destAddr := &mv 15646 if err := awsAwsquery_deserializeDocumentDoubleRange(&destAddr, nodeDecoder); err != nil { 15647 return err 15648 } 15649 mv = *destAddr 15650 sv = append(sv, mv) 15651 } 15652 *v = sv 15653 return nil 15654} 15655func awsAwsquery_deserializeDocumentEndpoint(v **types.Endpoint, decoder smithyxml.NodeDecoder) error { 15656 if v == nil { 15657 return fmt.Errorf("unexpected nil of type %T", v) 15658 } 15659 var sv *types.Endpoint 15660 if *v == nil { 15661 sv = &types.Endpoint{} 15662 } else { 15663 sv = *v 15664 } 15665 15666 for { 15667 t, done, err := decoder.Token() 15668 if err != nil { 15669 return err 15670 } 15671 if done { 15672 break 15673 } 15674 originalDecoder := decoder 15675 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15676 switch { 15677 case strings.EqualFold("Address", t.Name.Local): 15678 val, err := decoder.Value() 15679 if err != nil { 15680 return err 15681 } 15682 if val == nil { 15683 break 15684 } 15685 { 15686 xtv := string(val) 15687 sv.Address = ptr.String(xtv) 15688 } 15689 15690 case strings.EqualFold("HostedZoneId", t.Name.Local): 15691 val, err := decoder.Value() 15692 if err != nil { 15693 return err 15694 } 15695 if val == nil { 15696 break 15697 } 15698 { 15699 xtv := string(val) 15700 sv.HostedZoneId = ptr.String(xtv) 15701 } 15702 15703 case strings.EqualFold("Port", t.Name.Local): 15704 val, err := decoder.Value() 15705 if err != nil { 15706 return err 15707 } 15708 if val == nil { 15709 break 15710 } 15711 { 15712 xtv := string(val) 15713 i64, err := strconv.ParseInt(xtv, 10, 64) 15714 if err != nil { 15715 return err 15716 } 15717 sv.Port = int32(i64) 15718 } 15719 15720 default: 15721 // Do nothing and ignore the unexpected tag element 15722 err = decoder.Decoder.Skip() 15723 if err != nil { 15724 return err 15725 } 15726 15727 } 15728 decoder = originalDecoder 15729 } 15730 *v = sv 15731 return nil 15732} 15733 15734func awsAwsquery_deserializeDocumentEngineDefaults(v **types.EngineDefaults, decoder smithyxml.NodeDecoder) error { 15735 if v == nil { 15736 return fmt.Errorf("unexpected nil of type %T", v) 15737 } 15738 var sv *types.EngineDefaults 15739 if *v == nil { 15740 sv = &types.EngineDefaults{} 15741 } else { 15742 sv = *v 15743 } 15744 15745 for { 15746 t, done, err := decoder.Token() 15747 if err != nil { 15748 return err 15749 } 15750 if done { 15751 break 15752 } 15753 originalDecoder := decoder 15754 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15755 switch { 15756 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 15757 val, err := decoder.Value() 15758 if err != nil { 15759 return err 15760 } 15761 if val == nil { 15762 break 15763 } 15764 { 15765 xtv := string(val) 15766 sv.DBParameterGroupFamily = ptr.String(xtv) 15767 } 15768 15769 case strings.EqualFold("Marker", t.Name.Local): 15770 val, err := decoder.Value() 15771 if err != nil { 15772 return err 15773 } 15774 if val == nil { 15775 break 15776 } 15777 { 15778 xtv := string(val) 15779 sv.Marker = ptr.String(xtv) 15780 } 15781 15782 case strings.EqualFold("Parameters", t.Name.Local): 15783 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15784 if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { 15785 return err 15786 } 15787 15788 default: 15789 // Do nothing and ignore the unexpected tag element 15790 err = decoder.Decoder.Skip() 15791 if err != nil { 15792 return err 15793 } 15794 15795 } 15796 decoder = originalDecoder 15797 } 15798 *v = sv 15799 return nil 15800} 15801 15802func awsAwsquery_deserializeDocumentEvent(v **types.Event, decoder smithyxml.NodeDecoder) error { 15803 if v == nil { 15804 return fmt.Errorf("unexpected nil of type %T", v) 15805 } 15806 var sv *types.Event 15807 if *v == nil { 15808 sv = &types.Event{} 15809 } else { 15810 sv = *v 15811 } 15812 15813 for { 15814 t, done, err := decoder.Token() 15815 if err != nil { 15816 return err 15817 } 15818 if done { 15819 break 15820 } 15821 originalDecoder := decoder 15822 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15823 switch { 15824 case strings.EqualFold("Date", t.Name.Local): 15825 val, err := decoder.Value() 15826 if err != nil { 15827 return err 15828 } 15829 if val == nil { 15830 break 15831 } 15832 { 15833 xtv := string(val) 15834 t, err := smithytime.ParseDateTime(xtv) 15835 if err != nil { 15836 return err 15837 } 15838 sv.Date = ptr.Time(t) 15839 } 15840 15841 case strings.EqualFold("EventCategories", t.Name.Local): 15842 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15843 if err := awsAwsquery_deserializeDocumentEventCategoriesList(&sv.EventCategories, nodeDecoder); err != nil { 15844 return err 15845 } 15846 15847 case strings.EqualFold("Message", t.Name.Local): 15848 val, err := decoder.Value() 15849 if err != nil { 15850 return err 15851 } 15852 if val == nil { 15853 break 15854 } 15855 { 15856 xtv := string(val) 15857 sv.Message = ptr.String(xtv) 15858 } 15859 15860 case strings.EqualFold("SourceArn", t.Name.Local): 15861 val, err := decoder.Value() 15862 if err != nil { 15863 return err 15864 } 15865 if val == nil { 15866 break 15867 } 15868 { 15869 xtv := string(val) 15870 sv.SourceArn = ptr.String(xtv) 15871 } 15872 15873 case strings.EqualFold("SourceIdentifier", t.Name.Local): 15874 val, err := decoder.Value() 15875 if err != nil { 15876 return err 15877 } 15878 if val == nil { 15879 break 15880 } 15881 { 15882 xtv := string(val) 15883 sv.SourceIdentifier = ptr.String(xtv) 15884 } 15885 15886 case strings.EqualFold("SourceType", t.Name.Local): 15887 val, err := decoder.Value() 15888 if err != nil { 15889 return err 15890 } 15891 if val == nil { 15892 break 15893 } 15894 { 15895 xtv := string(val) 15896 sv.SourceType = types.SourceType(xtv) 15897 } 15898 15899 default: 15900 // Do nothing and ignore the unexpected tag element 15901 err = decoder.Decoder.Skip() 15902 if err != nil { 15903 return err 15904 } 15905 15906 } 15907 decoder = originalDecoder 15908 } 15909 *v = sv 15910 return nil 15911} 15912 15913func awsAwsquery_deserializeDocumentEventCategoriesList(v *[]string, decoder smithyxml.NodeDecoder) error { 15914 if v == nil { 15915 return fmt.Errorf("unexpected nil of type %T", v) 15916 } 15917 var sv []string 15918 if *v == nil { 15919 sv = make([]string, 0) 15920 } else { 15921 sv = *v 15922 } 15923 15924 originalDecoder := decoder 15925 for { 15926 t, done, err := decoder.Token() 15927 if err != nil { 15928 return err 15929 } 15930 if done { 15931 break 15932 } 15933 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15934 decoder = memberDecoder 15935 switch { 15936 case strings.EqualFold("EventCategory", t.Name.Local): 15937 var col string 15938 val, err := decoder.Value() 15939 if err != nil { 15940 return err 15941 } 15942 if val == nil { 15943 break 15944 } 15945 { 15946 xtv := string(val) 15947 col = xtv 15948 } 15949 sv = append(sv, col) 15950 15951 default: 15952 err = decoder.Decoder.Skip() 15953 if err != nil { 15954 return err 15955 } 15956 15957 } 15958 decoder = originalDecoder 15959 } 15960 *v = sv 15961 return nil 15962} 15963 15964func awsAwsquery_deserializeDocumentEventCategoriesListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 15965 var sv []string 15966 if *v == nil { 15967 sv = make([]string, 0) 15968 } else { 15969 sv = *v 15970 } 15971 15972 switch { 15973 default: 15974 var mv string 15975 t := decoder.StartEl 15976 _ = t 15977 val, err := decoder.Value() 15978 if err != nil { 15979 return err 15980 } 15981 if val == nil { 15982 break 15983 } 15984 { 15985 xtv := string(val) 15986 mv = xtv 15987 } 15988 sv = append(sv, mv) 15989 } 15990 *v = sv 15991 return nil 15992} 15993func awsAwsquery_deserializeDocumentEventCategoriesMap(v **types.EventCategoriesMap, decoder smithyxml.NodeDecoder) error { 15994 if v == nil { 15995 return fmt.Errorf("unexpected nil of type %T", v) 15996 } 15997 var sv *types.EventCategoriesMap 15998 if *v == nil { 15999 sv = &types.EventCategoriesMap{} 16000 } else { 16001 sv = *v 16002 } 16003 16004 for { 16005 t, done, err := decoder.Token() 16006 if err != nil { 16007 return err 16008 } 16009 if done { 16010 break 16011 } 16012 originalDecoder := decoder 16013 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16014 switch { 16015 case strings.EqualFold("EventCategories", t.Name.Local): 16016 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16017 if err := awsAwsquery_deserializeDocumentEventCategoriesList(&sv.EventCategories, nodeDecoder); err != nil { 16018 return err 16019 } 16020 16021 case strings.EqualFold("SourceType", t.Name.Local): 16022 val, err := decoder.Value() 16023 if err != nil { 16024 return err 16025 } 16026 if val == nil { 16027 break 16028 } 16029 { 16030 xtv := string(val) 16031 sv.SourceType = ptr.String(xtv) 16032 } 16033 16034 default: 16035 // Do nothing and ignore the unexpected tag element 16036 err = decoder.Decoder.Skip() 16037 if err != nil { 16038 return err 16039 } 16040 16041 } 16042 decoder = originalDecoder 16043 } 16044 *v = sv 16045 return nil 16046} 16047 16048func awsAwsquery_deserializeDocumentEventCategoriesMapList(v *[]types.EventCategoriesMap, decoder smithyxml.NodeDecoder) error { 16049 if v == nil { 16050 return fmt.Errorf("unexpected nil of type %T", v) 16051 } 16052 var sv []types.EventCategoriesMap 16053 if *v == nil { 16054 sv = make([]types.EventCategoriesMap, 0) 16055 } else { 16056 sv = *v 16057 } 16058 16059 originalDecoder := decoder 16060 for { 16061 t, done, err := decoder.Token() 16062 if err != nil { 16063 return err 16064 } 16065 if done { 16066 break 16067 } 16068 switch { 16069 case strings.EqualFold("EventCategoriesMap", t.Name.Local): 16070 var col types.EventCategoriesMap 16071 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16072 destAddr := &col 16073 if err := awsAwsquery_deserializeDocumentEventCategoriesMap(&destAddr, nodeDecoder); err != nil { 16074 return err 16075 } 16076 col = *destAddr 16077 sv = append(sv, col) 16078 16079 default: 16080 err = decoder.Decoder.Skip() 16081 if err != nil { 16082 return err 16083 } 16084 16085 } 16086 decoder = originalDecoder 16087 } 16088 *v = sv 16089 return nil 16090} 16091 16092func awsAwsquery_deserializeDocumentEventCategoriesMapListUnwrapped(v *[]types.EventCategoriesMap, decoder smithyxml.NodeDecoder) error { 16093 var sv []types.EventCategoriesMap 16094 if *v == nil { 16095 sv = make([]types.EventCategoriesMap, 0) 16096 } else { 16097 sv = *v 16098 } 16099 16100 switch { 16101 default: 16102 var mv types.EventCategoriesMap 16103 t := decoder.StartEl 16104 _ = t 16105 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16106 destAddr := &mv 16107 if err := awsAwsquery_deserializeDocumentEventCategoriesMap(&destAddr, nodeDecoder); err != nil { 16108 return err 16109 } 16110 mv = *destAddr 16111 sv = append(sv, mv) 16112 } 16113 *v = sv 16114 return nil 16115} 16116func awsAwsquery_deserializeDocumentEventList(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 16117 if v == nil { 16118 return fmt.Errorf("unexpected nil of type %T", v) 16119 } 16120 var sv []types.Event 16121 if *v == nil { 16122 sv = make([]types.Event, 0) 16123 } else { 16124 sv = *v 16125 } 16126 16127 originalDecoder := decoder 16128 for { 16129 t, done, err := decoder.Token() 16130 if err != nil { 16131 return err 16132 } 16133 if done { 16134 break 16135 } 16136 switch { 16137 case strings.EqualFold("Event", t.Name.Local): 16138 var col types.Event 16139 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16140 destAddr := &col 16141 if err := awsAwsquery_deserializeDocumentEvent(&destAddr, nodeDecoder); err != nil { 16142 return err 16143 } 16144 col = *destAddr 16145 sv = append(sv, col) 16146 16147 default: 16148 err = decoder.Decoder.Skip() 16149 if err != nil { 16150 return err 16151 } 16152 16153 } 16154 decoder = originalDecoder 16155 } 16156 *v = sv 16157 return nil 16158} 16159 16160func awsAwsquery_deserializeDocumentEventListUnwrapped(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 16161 var sv []types.Event 16162 if *v == nil { 16163 sv = make([]types.Event, 0) 16164 } else { 16165 sv = *v 16166 } 16167 16168 switch { 16169 default: 16170 var mv types.Event 16171 t := decoder.StartEl 16172 _ = t 16173 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16174 destAddr := &mv 16175 if err := awsAwsquery_deserializeDocumentEvent(&destAddr, nodeDecoder); err != nil { 16176 return err 16177 } 16178 mv = *destAddr 16179 sv = append(sv, mv) 16180 } 16181 *v = sv 16182 return nil 16183} 16184func awsAwsquery_deserializeDocumentEventSubscription(v **types.EventSubscription, decoder smithyxml.NodeDecoder) error { 16185 if v == nil { 16186 return fmt.Errorf("unexpected nil of type %T", v) 16187 } 16188 var sv *types.EventSubscription 16189 if *v == nil { 16190 sv = &types.EventSubscription{} 16191 } else { 16192 sv = *v 16193 } 16194 16195 for { 16196 t, done, err := decoder.Token() 16197 if err != nil { 16198 return err 16199 } 16200 if done { 16201 break 16202 } 16203 originalDecoder := decoder 16204 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16205 switch { 16206 case strings.EqualFold("CustomerAwsId", t.Name.Local): 16207 val, err := decoder.Value() 16208 if err != nil { 16209 return err 16210 } 16211 if val == nil { 16212 break 16213 } 16214 { 16215 xtv := string(val) 16216 sv.CustomerAwsId = ptr.String(xtv) 16217 } 16218 16219 case strings.EqualFold("CustSubscriptionId", t.Name.Local): 16220 val, err := decoder.Value() 16221 if err != nil { 16222 return err 16223 } 16224 if val == nil { 16225 break 16226 } 16227 { 16228 xtv := string(val) 16229 sv.CustSubscriptionId = ptr.String(xtv) 16230 } 16231 16232 case strings.EqualFold("Enabled", t.Name.Local): 16233 val, err := decoder.Value() 16234 if err != nil { 16235 return err 16236 } 16237 if val == nil { 16238 break 16239 } 16240 { 16241 xtv, err := strconv.ParseBool(string(val)) 16242 if err != nil { 16243 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 16244 } 16245 sv.Enabled = xtv 16246 } 16247 16248 case strings.EqualFold("EventCategoriesList", t.Name.Local): 16249 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16250 if err := awsAwsquery_deserializeDocumentEventCategoriesList(&sv.EventCategoriesList, nodeDecoder); err != nil { 16251 return err 16252 } 16253 16254 case strings.EqualFold("EventSubscriptionArn", t.Name.Local): 16255 val, err := decoder.Value() 16256 if err != nil { 16257 return err 16258 } 16259 if val == nil { 16260 break 16261 } 16262 { 16263 xtv := string(val) 16264 sv.EventSubscriptionArn = ptr.String(xtv) 16265 } 16266 16267 case strings.EqualFold("SnsTopicArn", t.Name.Local): 16268 val, err := decoder.Value() 16269 if err != nil { 16270 return err 16271 } 16272 if val == nil { 16273 break 16274 } 16275 { 16276 xtv := string(val) 16277 sv.SnsTopicArn = ptr.String(xtv) 16278 } 16279 16280 case strings.EqualFold("SourceIdsList", t.Name.Local): 16281 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16282 if err := awsAwsquery_deserializeDocumentSourceIdsList(&sv.SourceIdsList, nodeDecoder); err != nil { 16283 return err 16284 } 16285 16286 case strings.EqualFold("SourceType", t.Name.Local): 16287 val, err := decoder.Value() 16288 if err != nil { 16289 return err 16290 } 16291 if val == nil { 16292 break 16293 } 16294 { 16295 xtv := string(val) 16296 sv.SourceType = ptr.String(xtv) 16297 } 16298 16299 case strings.EqualFold("Status", t.Name.Local): 16300 val, err := decoder.Value() 16301 if err != nil { 16302 return err 16303 } 16304 if val == nil { 16305 break 16306 } 16307 { 16308 xtv := string(val) 16309 sv.Status = ptr.String(xtv) 16310 } 16311 16312 case strings.EqualFold("SubscriptionCreationTime", t.Name.Local): 16313 val, err := decoder.Value() 16314 if err != nil { 16315 return err 16316 } 16317 if val == nil { 16318 break 16319 } 16320 { 16321 xtv := string(val) 16322 sv.SubscriptionCreationTime = ptr.String(xtv) 16323 } 16324 16325 default: 16326 // Do nothing and ignore the unexpected tag element 16327 err = decoder.Decoder.Skip() 16328 if err != nil { 16329 return err 16330 } 16331 16332 } 16333 decoder = originalDecoder 16334 } 16335 *v = sv 16336 return nil 16337} 16338 16339func awsAwsquery_deserializeDocumentEventSubscriptionQuotaExceededFault(v **types.EventSubscriptionQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 16340 if v == nil { 16341 return fmt.Errorf("unexpected nil of type %T", v) 16342 } 16343 var sv *types.EventSubscriptionQuotaExceededFault 16344 if *v == nil { 16345 sv = &types.EventSubscriptionQuotaExceededFault{} 16346 } else { 16347 sv = *v 16348 } 16349 16350 for { 16351 t, done, err := decoder.Token() 16352 if err != nil { 16353 return err 16354 } 16355 if done { 16356 break 16357 } 16358 originalDecoder := decoder 16359 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16360 switch { 16361 case strings.EqualFold("message", t.Name.Local): 16362 val, err := decoder.Value() 16363 if err != nil { 16364 return err 16365 } 16366 if val == nil { 16367 break 16368 } 16369 { 16370 xtv := string(val) 16371 sv.Message = ptr.String(xtv) 16372 } 16373 16374 default: 16375 // Do nothing and ignore the unexpected tag element 16376 err = decoder.Decoder.Skip() 16377 if err != nil { 16378 return err 16379 } 16380 16381 } 16382 decoder = originalDecoder 16383 } 16384 *v = sv 16385 return nil 16386} 16387 16388func awsAwsquery_deserializeDocumentEventSubscriptionsList(v *[]types.EventSubscription, decoder smithyxml.NodeDecoder) error { 16389 if v == nil { 16390 return fmt.Errorf("unexpected nil of type %T", v) 16391 } 16392 var sv []types.EventSubscription 16393 if *v == nil { 16394 sv = make([]types.EventSubscription, 0) 16395 } else { 16396 sv = *v 16397 } 16398 16399 originalDecoder := decoder 16400 for { 16401 t, done, err := decoder.Token() 16402 if err != nil { 16403 return err 16404 } 16405 if done { 16406 break 16407 } 16408 switch { 16409 case strings.EqualFold("EventSubscription", t.Name.Local): 16410 var col types.EventSubscription 16411 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16412 destAddr := &col 16413 if err := awsAwsquery_deserializeDocumentEventSubscription(&destAddr, nodeDecoder); err != nil { 16414 return err 16415 } 16416 col = *destAddr 16417 sv = append(sv, col) 16418 16419 default: 16420 err = decoder.Decoder.Skip() 16421 if err != nil { 16422 return err 16423 } 16424 16425 } 16426 decoder = originalDecoder 16427 } 16428 *v = sv 16429 return nil 16430} 16431 16432func awsAwsquery_deserializeDocumentEventSubscriptionsListUnwrapped(v *[]types.EventSubscription, decoder smithyxml.NodeDecoder) error { 16433 var sv []types.EventSubscription 16434 if *v == nil { 16435 sv = make([]types.EventSubscription, 0) 16436 } else { 16437 sv = *v 16438 } 16439 16440 switch { 16441 default: 16442 var mv types.EventSubscription 16443 t := decoder.StartEl 16444 _ = t 16445 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16446 destAddr := &mv 16447 if err := awsAwsquery_deserializeDocumentEventSubscription(&destAddr, nodeDecoder); err != nil { 16448 return err 16449 } 16450 mv = *destAddr 16451 sv = append(sv, mv) 16452 } 16453 *v = sv 16454 return nil 16455} 16456func awsAwsquery_deserializeDocumentInstanceQuotaExceededFault(v **types.InstanceQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 16457 if v == nil { 16458 return fmt.Errorf("unexpected nil of type %T", v) 16459 } 16460 var sv *types.InstanceQuotaExceededFault 16461 if *v == nil { 16462 sv = &types.InstanceQuotaExceededFault{} 16463 } else { 16464 sv = *v 16465 } 16466 16467 for { 16468 t, done, err := decoder.Token() 16469 if err != nil { 16470 return err 16471 } 16472 if done { 16473 break 16474 } 16475 originalDecoder := decoder 16476 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16477 switch { 16478 case strings.EqualFold("message", t.Name.Local): 16479 val, err := decoder.Value() 16480 if err != nil { 16481 return err 16482 } 16483 if val == nil { 16484 break 16485 } 16486 { 16487 xtv := string(val) 16488 sv.Message = ptr.String(xtv) 16489 } 16490 16491 default: 16492 // Do nothing and ignore the unexpected tag element 16493 err = decoder.Decoder.Skip() 16494 if err != nil { 16495 return err 16496 } 16497 16498 } 16499 decoder = originalDecoder 16500 } 16501 *v = sv 16502 return nil 16503} 16504 16505func awsAwsquery_deserializeDocumentInsufficientDBClusterCapacityFault(v **types.InsufficientDBClusterCapacityFault, decoder smithyxml.NodeDecoder) error { 16506 if v == nil { 16507 return fmt.Errorf("unexpected nil of type %T", v) 16508 } 16509 var sv *types.InsufficientDBClusterCapacityFault 16510 if *v == nil { 16511 sv = &types.InsufficientDBClusterCapacityFault{} 16512 } else { 16513 sv = *v 16514 } 16515 16516 for { 16517 t, done, err := decoder.Token() 16518 if err != nil { 16519 return err 16520 } 16521 if done { 16522 break 16523 } 16524 originalDecoder := decoder 16525 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16526 switch { 16527 case strings.EqualFold("message", t.Name.Local): 16528 val, err := decoder.Value() 16529 if err != nil { 16530 return err 16531 } 16532 if val == nil { 16533 break 16534 } 16535 { 16536 xtv := string(val) 16537 sv.Message = ptr.String(xtv) 16538 } 16539 16540 default: 16541 // Do nothing and ignore the unexpected tag element 16542 err = decoder.Decoder.Skip() 16543 if err != nil { 16544 return err 16545 } 16546 16547 } 16548 decoder = originalDecoder 16549 } 16550 *v = sv 16551 return nil 16552} 16553 16554func awsAwsquery_deserializeDocumentInsufficientDBInstanceCapacityFault(v **types.InsufficientDBInstanceCapacityFault, decoder smithyxml.NodeDecoder) error { 16555 if v == nil { 16556 return fmt.Errorf("unexpected nil of type %T", v) 16557 } 16558 var sv *types.InsufficientDBInstanceCapacityFault 16559 if *v == nil { 16560 sv = &types.InsufficientDBInstanceCapacityFault{} 16561 } else { 16562 sv = *v 16563 } 16564 16565 for { 16566 t, done, err := decoder.Token() 16567 if err != nil { 16568 return err 16569 } 16570 if done { 16571 break 16572 } 16573 originalDecoder := decoder 16574 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16575 switch { 16576 case strings.EqualFold("message", t.Name.Local): 16577 val, err := decoder.Value() 16578 if err != nil { 16579 return err 16580 } 16581 if val == nil { 16582 break 16583 } 16584 { 16585 xtv := string(val) 16586 sv.Message = ptr.String(xtv) 16587 } 16588 16589 default: 16590 // Do nothing and ignore the unexpected tag element 16591 err = decoder.Decoder.Skip() 16592 if err != nil { 16593 return err 16594 } 16595 16596 } 16597 decoder = originalDecoder 16598 } 16599 *v = sv 16600 return nil 16601} 16602 16603func awsAwsquery_deserializeDocumentInsufficientStorageClusterCapacityFault(v **types.InsufficientStorageClusterCapacityFault, decoder smithyxml.NodeDecoder) error { 16604 if v == nil { 16605 return fmt.Errorf("unexpected nil of type %T", v) 16606 } 16607 var sv *types.InsufficientStorageClusterCapacityFault 16608 if *v == nil { 16609 sv = &types.InsufficientStorageClusterCapacityFault{} 16610 } else { 16611 sv = *v 16612 } 16613 16614 for { 16615 t, done, err := decoder.Token() 16616 if err != nil { 16617 return err 16618 } 16619 if done { 16620 break 16621 } 16622 originalDecoder := decoder 16623 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16624 switch { 16625 case strings.EqualFold("message", t.Name.Local): 16626 val, err := decoder.Value() 16627 if err != nil { 16628 return err 16629 } 16630 if val == nil { 16631 break 16632 } 16633 { 16634 xtv := string(val) 16635 sv.Message = ptr.String(xtv) 16636 } 16637 16638 default: 16639 // Do nothing and ignore the unexpected tag element 16640 err = decoder.Decoder.Skip() 16641 if err != nil { 16642 return err 16643 } 16644 16645 } 16646 decoder = originalDecoder 16647 } 16648 *v = sv 16649 return nil 16650} 16651 16652func awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(v **types.InvalidDBClusterEndpointStateFault, decoder smithyxml.NodeDecoder) error { 16653 if v == nil { 16654 return fmt.Errorf("unexpected nil of type %T", v) 16655 } 16656 var sv *types.InvalidDBClusterEndpointStateFault 16657 if *v == nil { 16658 sv = &types.InvalidDBClusterEndpointStateFault{} 16659 } else { 16660 sv = *v 16661 } 16662 16663 for { 16664 t, done, err := decoder.Token() 16665 if err != nil { 16666 return err 16667 } 16668 if done { 16669 break 16670 } 16671 originalDecoder := decoder 16672 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16673 switch { 16674 case strings.EqualFold("message", t.Name.Local): 16675 val, err := decoder.Value() 16676 if err != nil { 16677 return err 16678 } 16679 if val == nil { 16680 break 16681 } 16682 { 16683 xtv := string(val) 16684 sv.Message = ptr.String(xtv) 16685 } 16686 16687 default: 16688 // Do nothing and ignore the unexpected tag element 16689 err = decoder.Decoder.Skip() 16690 if err != nil { 16691 return err 16692 } 16693 16694 } 16695 decoder = originalDecoder 16696 } 16697 *v = sv 16698 return nil 16699} 16700 16701func awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(v **types.InvalidDBClusterSnapshotStateFault, decoder smithyxml.NodeDecoder) error { 16702 if v == nil { 16703 return fmt.Errorf("unexpected nil of type %T", v) 16704 } 16705 var sv *types.InvalidDBClusterSnapshotStateFault 16706 if *v == nil { 16707 sv = &types.InvalidDBClusterSnapshotStateFault{} 16708 } else { 16709 sv = *v 16710 } 16711 16712 for { 16713 t, done, err := decoder.Token() 16714 if err != nil { 16715 return err 16716 } 16717 if done { 16718 break 16719 } 16720 originalDecoder := decoder 16721 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16722 switch { 16723 case strings.EqualFold("message", t.Name.Local): 16724 val, err := decoder.Value() 16725 if err != nil { 16726 return err 16727 } 16728 if val == nil { 16729 break 16730 } 16731 { 16732 xtv := string(val) 16733 sv.Message = ptr.String(xtv) 16734 } 16735 16736 default: 16737 // Do nothing and ignore the unexpected tag element 16738 err = decoder.Decoder.Skip() 16739 if err != nil { 16740 return err 16741 } 16742 16743 } 16744 decoder = originalDecoder 16745 } 16746 *v = sv 16747 return nil 16748} 16749 16750func awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(v **types.InvalidDBClusterStateFault, decoder smithyxml.NodeDecoder) error { 16751 if v == nil { 16752 return fmt.Errorf("unexpected nil of type %T", v) 16753 } 16754 var sv *types.InvalidDBClusterStateFault 16755 if *v == nil { 16756 sv = &types.InvalidDBClusterStateFault{} 16757 } else { 16758 sv = *v 16759 } 16760 16761 for { 16762 t, done, err := decoder.Token() 16763 if err != nil { 16764 return err 16765 } 16766 if done { 16767 break 16768 } 16769 originalDecoder := decoder 16770 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16771 switch { 16772 case strings.EqualFold("message", t.Name.Local): 16773 val, err := decoder.Value() 16774 if err != nil { 16775 return err 16776 } 16777 if val == nil { 16778 break 16779 } 16780 { 16781 xtv := string(val) 16782 sv.Message = ptr.String(xtv) 16783 } 16784 16785 default: 16786 // Do nothing and ignore the unexpected tag element 16787 err = decoder.Decoder.Skip() 16788 if err != nil { 16789 return err 16790 } 16791 16792 } 16793 decoder = originalDecoder 16794 } 16795 *v = sv 16796 return nil 16797} 16798 16799func awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(v **types.InvalidDBInstanceStateFault, decoder smithyxml.NodeDecoder) error { 16800 if v == nil { 16801 return fmt.Errorf("unexpected nil of type %T", v) 16802 } 16803 var sv *types.InvalidDBInstanceStateFault 16804 if *v == nil { 16805 sv = &types.InvalidDBInstanceStateFault{} 16806 } else { 16807 sv = *v 16808 } 16809 16810 for { 16811 t, done, err := decoder.Token() 16812 if err != nil { 16813 return err 16814 } 16815 if done { 16816 break 16817 } 16818 originalDecoder := decoder 16819 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16820 switch { 16821 case strings.EqualFold("message", t.Name.Local): 16822 val, err := decoder.Value() 16823 if err != nil { 16824 return err 16825 } 16826 if val == nil { 16827 break 16828 } 16829 { 16830 xtv := string(val) 16831 sv.Message = ptr.String(xtv) 16832 } 16833 16834 default: 16835 // Do nothing and ignore the unexpected tag element 16836 err = decoder.Decoder.Skip() 16837 if err != nil { 16838 return err 16839 } 16840 16841 } 16842 decoder = originalDecoder 16843 } 16844 *v = sv 16845 return nil 16846} 16847 16848func awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(v **types.InvalidDBParameterGroupStateFault, decoder smithyxml.NodeDecoder) error { 16849 if v == nil { 16850 return fmt.Errorf("unexpected nil of type %T", v) 16851 } 16852 var sv *types.InvalidDBParameterGroupStateFault 16853 if *v == nil { 16854 sv = &types.InvalidDBParameterGroupStateFault{} 16855 } else { 16856 sv = *v 16857 } 16858 16859 for { 16860 t, done, err := decoder.Token() 16861 if err != nil { 16862 return err 16863 } 16864 if done { 16865 break 16866 } 16867 originalDecoder := decoder 16868 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16869 switch { 16870 case strings.EqualFold("message", t.Name.Local): 16871 val, err := decoder.Value() 16872 if err != nil { 16873 return err 16874 } 16875 if val == nil { 16876 break 16877 } 16878 { 16879 xtv := string(val) 16880 sv.Message = ptr.String(xtv) 16881 } 16882 16883 default: 16884 // Do nothing and ignore the unexpected tag element 16885 err = decoder.Decoder.Skip() 16886 if err != nil { 16887 return err 16888 } 16889 16890 } 16891 decoder = originalDecoder 16892 } 16893 *v = sv 16894 return nil 16895} 16896 16897func awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(v **types.InvalidDBSecurityGroupStateFault, decoder smithyxml.NodeDecoder) error { 16898 if v == nil { 16899 return fmt.Errorf("unexpected nil of type %T", v) 16900 } 16901 var sv *types.InvalidDBSecurityGroupStateFault 16902 if *v == nil { 16903 sv = &types.InvalidDBSecurityGroupStateFault{} 16904 } else { 16905 sv = *v 16906 } 16907 16908 for { 16909 t, done, err := decoder.Token() 16910 if err != nil { 16911 return err 16912 } 16913 if done { 16914 break 16915 } 16916 originalDecoder := decoder 16917 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16918 switch { 16919 case strings.EqualFold("message", t.Name.Local): 16920 val, err := decoder.Value() 16921 if err != nil { 16922 return err 16923 } 16924 if val == nil { 16925 break 16926 } 16927 { 16928 xtv := string(val) 16929 sv.Message = ptr.String(xtv) 16930 } 16931 16932 default: 16933 // Do nothing and ignore the unexpected tag element 16934 err = decoder.Decoder.Skip() 16935 if err != nil { 16936 return err 16937 } 16938 16939 } 16940 decoder = originalDecoder 16941 } 16942 *v = sv 16943 return nil 16944} 16945 16946func awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(v **types.InvalidDBSnapshotStateFault, decoder smithyxml.NodeDecoder) error { 16947 if v == nil { 16948 return fmt.Errorf("unexpected nil of type %T", v) 16949 } 16950 var sv *types.InvalidDBSnapshotStateFault 16951 if *v == nil { 16952 sv = &types.InvalidDBSnapshotStateFault{} 16953 } else { 16954 sv = *v 16955 } 16956 16957 for { 16958 t, done, err := decoder.Token() 16959 if err != nil { 16960 return err 16961 } 16962 if done { 16963 break 16964 } 16965 originalDecoder := decoder 16966 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16967 switch { 16968 case strings.EqualFold("message", t.Name.Local): 16969 val, err := decoder.Value() 16970 if err != nil { 16971 return err 16972 } 16973 if val == nil { 16974 break 16975 } 16976 { 16977 xtv := string(val) 16978 sv.Message = ptr.String(xtv) 16979 } 16980 16981 default: 16982 // Do nothing and ignore the unexpected tag element 16983 err = decoder.Decoder.Skip() 16984 if err != nil { 16985 return err 16986 } 16987 16988 } 16989 decoder = originalDecoder 16990 } 16991 *v = sv 16992 return nil 16993} 16994 16995func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(v **types.InvalidDBSubnetGroupStateFault, decoder smithyxml.NodeDecoder) error { 16996 if v == nil { 16997 return fmt.Errorf("unexpected nil of type %T", v) 16998 } 16999 var sv *types.InvalidDBSubnetGroupStateFault 17000 if *v == nil { 17001 sv = &types.InvalidDBSubnetGroupStateFault{} 17002 } else { 17003 sv = *v 17004 } 17005 17006 for { 17007 t, done, err := decoder.Token() 17008 if err != nil { 17009 return err 17010 } 17011 if done { 17012 break 17013 } 17014 originalDecoder := decoder 17015 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17016 switch { 17017 case strings.EqualFold("message", t.Name.Local): 17018 val, err := decoder.Value() 17019 if err != nil { 17020 return err 17021 } 17022 if val == nil { 17023 break 17024 } 17025 { 17026 xtv := string(val) 17027 sv.Message = ptr.String(xtv) 17028 } 17029 17030 default: 17031 // Do nothing and ignore the unexpected tag element 17032 err = decoder.Decoder.Skip() 17033 if err != nil { 17034 return err 17035 } 17036 17037 } 17038 decoder = originalDecoder 17039 } 17040 *v = sv 17041 return nil 17042} 17043 17044func awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(v **types.InvalidDBSubnetStateFault, decoder smithyxml.NodeDecoder) error { 17045 if v == nil { 17046 return fmt.Errorf("unexpected nil of type %T", v) 17047 } 17048 var sv *types.InvalidDBSubnetStateFault 17049 if *v == nil { 17050 sv = &types.InvalidDBSubnetStateFault{} 17051 } else { 17052 sv = *v 17053 } 17054 17055 for { 17056 t, done, err := decoder.Token() 17057 if err != nil { 17058 return err 17059 } 17060 if done { 17061 break 17062 } 17063 originalDecoder := decoder 17064 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17065 switch { 17066 case strings.EqualFold("message", t.Name.Local): 17067 val, err := decoder.Value() 17068 if err != nil { 17069 return err 17070 } 17071 if val == nil { 17072 break 17073 } 17074 { 17075 xtv := string(val) 17076 sv.Message = ptr.String(xtv) 17077 } 17078 17079 default: 17080 // Do nothing and ignore the unexpected tag element 17081 err = decoder.Decoder.Skip() 17082 if err != nil { 17083 return err 17084 } 17085 17086 } 17087 decoder = originalDecoder 17088 } 17089 *v = sv 17090 return nil 17091} 17092 17093func awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(v **types.InvalidEventSubscriptionStateFault, decoder smithyxml.NodeDecoder) error { 17094 if v == nil { 17095 return fmt.Errorf("unexpected nil of type %T", v) 17096 } 17097 var sv *types.InvalidEventSubscriptionStateFault 17098 if *v == nil { 17099 sv = &types.InvalidEventSubscriptionStateFault{} 17100 } else { 17101 sv = *v 17102 } 17103 17104 for { 17105 t, done, err := decoder.Token() 17106 if err != nil { 17107 return err 17108 } 17109 if done { 17110 break 17111 } 17112 originalDecoder := decoder 17113 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17114 switch { 17115 case strings.EqualFold("message", t.Name.Local): 17116 val, err := decoder.Value() 17117 if err != nil { 17118 return err 17119 } 17120 if val == nil { 17121 break 17122 } 17123 { 17124 xtv := string(val) 17125 sv.Message = ptr.String(xtv) 17126 } 17127 17128 default: 17129 // Do nothing and ignore the unexpected tag element 17130 err = decoder.Decoder.Skip() 17131 if err != nil { 17132 return err 17133 } 17134 17135 } 17136 decoder = originalDecoder 17137 } 17138 *v = sv 17139 return nil 17140} 17141 17142func awsAwsquery_deserializeDocumentInvalidRestoreFault(v **types.InvalidRestoreFault, decoder smithyxml.NodeDecoder) error { 17143 if v == nil { 17144 return fmt.Errorf("unexpected nil of type %T", v) 17145 } 17146 var sv *types.InvalidRestoreFault 17147 if *v == nil { 17148 sv = &types.InvalidRestoreFault{} 17149 } else { 17150 sv = *v 17151 } 17152 17153 for { 17154 t, done, err := decoder.Token() 17155 if err != nil { 17156 return err 17157 } 17158 if done { 17159 break 17160 } 17161 originalDecoder := decoder 17162 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17163 switch { 17164 case strings.EqualFold("message", t.Name.Local): 17165 val, err := decoder.Value() 17166 if err != nil { 17167 return err 17168 } 17169 if val == nil { 17170 break 17171 } 17172 { 17173 xtv := string(val) 17174 sv.Message = ptr.String(xtv) 17175 } 17176 17177 default: 17178 // Do nothing and ignore the unexpected tag element 17179 err = decoder.Decoder.Skip() 17180 if err != nil { 17181 return err 17182 } 17183 17184 } 17185 decoder = originalDecoder 17186 } 17187 *v = sv 17188 return nil 17189} 17190 17191func awsAwsquery_deserializeDocumentInvalidSubnet(v **types.InvalidSubnet, decoder smithyxml.NodeDecoder) error { 17192 if v == nil { 17193 return fmt.Errorf("unexpected nil of type %T", v) 17194 } 17195 var sv *types.InvalidSubnet 17196 if *v == nil { 17197 sv = &types.InvalidSubnet{} 17198 } else { 17199 sv = *v 17200 } 17201 17202 for { 17203 t, done, err := decoder.Token() 17204 if err != nil { 17205 return err 17206 } 17207 if done { 17208 break 17209 } 17210 originalDecoder := decoder 17211 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17212 switch { 17213 case strings.EqualFold("message", t.Name.Local): 17214 val, err := decoder.Value() 17215 if err != nil { 17216 return err 17217 } 17218 if val == nil { 17219 break 17220 } 17221 { 17222 xtv := string(val) 17223 sv.Message = ptr.String(xtv) 17224 } 17225 17226 default: 17227 // Do nothing and ignore the unexpected tag element 17228 err = decoder.Decoder.Skip() 17229 if err != nil { 17230 return err 17231 } 17232 17233 } 17234 decoder = originalDecoder 17235 } 17236 *v = sv 17237 return nil 17238} 17239 17240func awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(v **types.InvalidVPCNetworkStateFault, decoder smithyxml.NodeDecoder) error { 17241 if v == nil { 17242 return fmt.Errorf("unexpected nil of type %T", v) 17243 } 17244 var sv *types.InvalidVPCNetworkStateFault 17245 if *v == nil { 17246 sv = &types.InvalidVPCNetworkStateFault{} 17247 } else { 17248 sv = *v 17249 } 17250 17251 for { 17252 t, done, err := decoder.Token() 17253 if err != nil { 17254 return err 17255 } 17256 if done { 17257 break 17258 } 17259 originalDecoder := decoder 17260 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17261 switch { 17262 case strings.EqualFold("message", t.Name.Local): 17263 val, err := decoder.Value() 17264 if err != nil { 17265 return err 17266 } 17267 if val == nil { 17268 break 17269 } 17270 { 17271 xtv := string(val) 17272 sv.Message = ptr.String(xtv) 17273 } 17274 17275 default: 17276 // Do nothing and ignore the unexpected tag element 17277 err = decoder.Decoder.Skip() 17278 if err != nil { 17279 return err 17280 } 17281 17282 } 17283 decoder = originalDecoder 17284 } 17285 *v = sv 17286 return nil 17287} 17288 17289func awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(v **types.KMSKeyNotAccessibleFault, decoder smithyxml.NodeDecoder) error { 17290 if v == nil { 17291 return fmt.Errorf("unexpected nil of type %T", v) 17292 } 17293 var sv *types.KMSKeyNotAccessibleFault 17294 if *v == nil { 17295 sv = &types.KMSKeyNotAccessibleFault{} 17296 } else { 17297 sv = *v 17298 } 17299 17300 for { 17301 t, done, err := decoder.Token() 17302 if err != nil { 17303 return err 17304 } 17305 if done { 17306 break 17307 } 17308 originalDecoder := decoder 17309 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17310 switch { 17311 case strings.EqualFold("message", t.Name.Local): 17312 val, err := decoder.Value() 17313 if err != nil { 17314 return err 17315 } 17316 if val == nil { 17317 break 17318 } 17319 { 17320 xtv := string(val) 17321 sv.Message = ptr.String(xtv) 17322 } 17323 17324 default: 17325 // Do nothing and ignore the unexpected tag element 17326 err = decoder.Decoder.Skip() 17327 if err != nil { 17328 return err 17329 } 17330 17331 } 17332 decoder = originalDecoder 17333 } 17334 *v = sv 17335 return nil 17336} 17337 17338func awsAwsquery_deserializeDocumentLogTypeList(v *[]string, decoder smithyxml.NodeDecoder) error { 17339 if v == nil { 17340 return fmt.Errorf("unexpected nil of type %T", v) 17341 } 17342 var sv []string 17343 if *v == nil { 17344 sv = make([]string, 0) 17345 } else { 17346 sv = *v 17347 } 17348 17349 originalDecoder := decoder 17350 for { 17351 t, done, err := decoder.Token() 17352 if err != nil { 17353 return err 17354 } 17355 if done { 17356 break 17357 } 17358 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17359 decoder = memberDecoder 17360 switch { 17361 case strings.EqualFold("member", t.Name.Local): 17362 var col string 17363 val, err := decoder.Value() 17364 if err != nil { 17365 return err 17366 } 17367 if val == nil { 17368 break 17369 } 17370 { 17371 xtv := string(val) 17372 col = xtv 17373 } 17374 sv = append(sv, col) 17375 17376 default: 17377 err = decoder.Decoder.Skip() 17378 if err != nil { 17379 return err 17380 } 17381 17382 } 17383 decoder = originalDecoder 17384 } 17385 *v = sv 17386 return nil 17387} 17388 17389func awsAwsquery_deserializeDocumentLogTypeListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 17390 var sv []string 17391 if *v == nil { 17392 sv = make([]string, 0) 17393 } else { 17394 sv = *v 17395 } 17396 17397 switch { 17398 default: 17399 var mv string 17400 t := decoder.StartEl 17401 _ = t 17402 val, err := decoder.Value() 17403 if err != nil { 17404 return err 17405 } 17406 if val == nil { 17407 break 17408 } 17409 { 17410 xtv := string(val) 17411 mv = xtv 17412 } 17413 sv = append(sv, mv) 17414 } 17415 *v = sv 17416 return nil 17417} 17418func awsAwsquery_deserializeDocumentOptionGroupMembership(v **types.OptionGroupMembership, decoder smithyxml.NodeDecoder) error { 17419 if v == nil { 17420 return fmt.Errorf("unexpected nil of type %T", v) 17421 } 17422 var sv *types.OptionGroupMembership 17423 if *v == nil { 17424 sv = &types.OptionGroupMembership{} 17425 } else { 17426 sv = *v 17427 } 17428 17429 for { 17430 t, done, err := decoder.Token() 17431 if err != nil { 17432 return err 17433 } 17434 if done { 17435 break 17436 } 17437 originalDecoder := decoder 17438 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17439 switch { 17440 case strings.EqualFold("OptionGroupName", t.Name.Local): 17441 val, err := decoder.Value() 17442 if err != nil { 17443 return err 17444 } 17445 if val == nil { 17446 break 17447 } 17448 { 17449 xtv := string(val) 17450 sv.OptionGroupName = ptr.String(xtv) 17451 } 17452 17453 case strings.EqualFold("Status", t.Name.Local): 17454 val, err := decoder.Value() 17455 if err != nil { 17456 return err 17457 } 17458 if val == nil { 17459 break 17460 } 17461 { 17462 xtv := string(val) 17463 sv.Status = ptr.String(xtv) 17464 } 17465 17466 default: 17467 // Do nothing and ignore the unexpected tag element 17468 err = decoder.Decoder.Skip() 17469 if err != nil { 17470 return err 17471 } 17472 17473 } 17474 decoder = originalDecoder 17475 } 17476 *v = sv 17477 return nil 17478} 17479 17480func awsAwsquery_deserializeDocumentOptionGroupMembershipList(v *[]types.OptionGroupMembership, decoder smithyxml.NodeDecoder) error { 17481 if v == nil { 17482 return fmt.Errorf("unexpected nil of type %T", v) 17483 } 17484 var sv []types.OptionGroupMembership 17485 if *v == nil { 17486 sv = make([]types.OptionGroupMembership, 0) 17487 } else { 17488 sv = *v 17489 } 17490 17491 originalDecoder := decoder 17492 for { 17493 t, done, err := decoder.Token() 17494 if err != nil { 17495 return err 17496 } 17497 if done { 17498 break 17499 } 17500 switch { 17501 case strings.EqualFold("OptionGroupMembership", t.Name.Local): 17502 var col types.OptionGroupMembership 17503 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17504 destAddr := &col 17505 if err := awsAwsquery_deserializeDocumentOptionGroupMembership(&destAddr, nodeDecoder); err != nil { 17506 return err 17507 } 17508 col = *destAddr 17509 sv = append(sv, col) 17510 17511 default: 17512 err = decoder.Decoder.Skip() 17513 if err != nil { 17514 return err 17515 } 17516 17517 } 17518 decoder = originalDecoder 17519 } 17520 *v = sv 17521 return nil 17522} 17523 17524func awsAwsquery_deserializeDocumentOptionGroupMembershipListUnwrapped(v *[]types.OptionGroupMembership, decoder smithyxml.NodeDecoder) error { 17525 var sv []types.OptionGroupMembership 17526 if *v == nil { 17527 sv = make([]types.OptionGroupMembership, 0) 17528 } else { 17529 sv = *v 17530 } 17531 17532 switch { 17533 default: 17534 var mv types.OptionGroupMembership 17535 t := decoder.StartEl 17536 _ = t 17537 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17538 destAddr := &mv 17539 if err := awsAwsquery_deserializeDocumentOptionGroupMembership(&destAddr, nodeDecoder); err != nil { 17540 return err 17541 } 17542 mv = *destAddr 17543 sv = append(sv, mv) 17544 } 17545 *v = sv 17546 return nil 17547} 17548func awsAwsquery_deserializeDocumentOptionGroupNotFoundFault(v **types.OptionGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 17549 if v == nil { 17550 return fmt.Errorf("unexpected nil of type %T", v) 17551 } 17552 var sv *types.OptionGroupNotFoundFault 17553 if *v == nil { 17554 sv = &types.OptionGroupNotFoundFault{} 17555 } else { 17556 sv = *v 17557 } 17558 17559 for { 17560 t, done, err := decoder.Token() 17561 if err != nil { 17562 return err 17563 } 17564 if done { 17565 break 17566 } 17567 originalDecoder := decoder 17568 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17569 switch { 17570 case strings.EqualFold("message", t.Name.Local): 17571 val, err := decoder.Value() 17572 if err != nil { 17573 return err 17574 } 17575 if val == nil { 17576 break 17577 } 17578 { 17579 xtv := string(val) 17580 sv.Message = ptr.String(xtv) 17581 } 17582 17583 default: 17584 // Do nothing and ignore the unexpected tag element 17585 err = decoder.Decoder.Skip() 17586 if err != nil { 17587 return err 17588 } 17589 17590 } 17591 decoder = originalDecoder 17592 } 17593 *v = sv 17594 return nil 17595} 17596 17597func awsAwsquery_deserializeDocumentOrderableDBInstanceOption(v **types.OrderableDBInstanceOption, decoder smithyxml.NodeDecoder) error { 17598 if v == nil { 17599 return fmt.Errorf("unexpected nil of type %T", v) 17600 } 17601 var sv *types.OrderableDBInstanceOption 17602 if *v == nil { 17603 sv = &types.OrderableDBInstanceOption{} 17604 } else { 17605 sv = *v 17606 } 17607 17608 for { 17609 t, done, err := decoder.Token() 17610 if err != nil { 17611 return err 17612 } 17613 if done { 17614 break 17615 } 17616 originalDecoder := decoder 17617 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17618 switch { 17619 case strings.EqualFold("AvailabilityZones", t.Name.Local): 17620 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17621 if err := awsAwsquery_deserializeDocumentAvailabilityZoneList(&sv.AvailabilityZones, nodeDecoder); err != nil { 17622 return err 17623 } 17624 17625 case strings.EqualFold("DBInstanceClass", t.Name.Local): 17626 val, err := decoder.Value() 17627 if err != nil { 17628 return err 17629 } 17630 if val == nil { 17631 break 17632 } 17633 { 17634 xtv := string(val) 17635 sv.DBInstanceClass = ptr.String(xtv) 17636 } 17637 17638 case strings.EqualFold("Engine", t.Name.Local): 17639 val, err := decoder.Value() 17640 if err != nil { 17641 return err 17642 } 17643 if val == nil { 17644 break 17645 } 17646 { 17647 xtv := string(val) 17648 sv.Engine = ptr.String(xtv) 17649 } 17650 17651 case strings.EqualFold("EngineVersion", t.Name.Local): 17652 val, err := decoder.Value() 17653 if err != nil { 17654 return err 17655 } 17656 if val == nil { 17657 break 17658 } 17659 { 17660 xtv := string(val) 17661 sv.EngineVersion = ptr.String(xtv) 17662 } 17663 17664 case strings.EqualFold("LicenseModel", t.Name.Local): 17665 val, err := decoder.Value() 17666 if err != nil { 17667 return err 17668 } 17669 if val == nil { 17670 break 17671 } 17672 { 17673 xtv := string(val) 17674 sv.LicenseModel = ptr.String(xtv) 17675 } 17676 17677 case strings.EqualFold("MaxIopsPerDbInstance", t.Name.Local): 17678 val, err := decoder.Value() 17679 if err != nil { 17680 return err 17681 } 17682 if val == nil { 17683 break 17684 } 17685 { 17686 xtv := string(val) 17687 i64, err := strconv.ParseInt(xtv, 10, 64) 17688 if err != nil { 17689 return err 17690 } 17691 sv.MaxIopsPerDbInstance = ptr.Int32(int32(i64)) 17692 } 17693 17694 case strings.EqualFold("MaxIopsPerGib", t.Name.Local): 17695 val, err := decoder.Value() 17696 if err != nil { 17697 return err 17698 } 17699 if val == nil { 17700 break 17701 } 17702 { 17703 xtv := string(val) 17704 f64, err := strconv.ParseFloat(xtv, 64) 17705 if err != nil { 17706 return err 17707 } 17708 sv.MaxIopsPerGib = ptr.Float64(f64) 17709 } 17710 17711 case strings.EqualFold("MaxStorageSize", t.Name.Local): 17712 val, err := decoder.Value() 17713 if err != nil { 17714 return err 17715 } 17716 if val == nil { 17717 break 17718 } 17719 { 17720 xtv := string(val) 17721 i64, err := strconv.ParseInt(xtv, 10, 64) 17722 if err != nil { 17723 return err 17724 } 17725 sv.MaxStorageSize = ptr.Int32(int32(i64)) 17726 } 17727 17728 case strings.EqualFold("MinIopsPerDbInstance", t.Name.Local): 17729 val, err := decoder.Value() 17730 if err != nil { 17731 return err 17732 } 17733 if val == nil { 17734 break 17735 } 17736 { 17737 xtv := string(val) 17738 i64, err := strconv.ParseInt(xtv, 10, 64) 17739 if err != nil { 17740 return err 17741 } 17742 sv.MinIopsPerDbInstance = ptr.Int32(int32(i64)) 17743 } 17744 17745 case strings.EqualFold("MinIopsPerGib", t.Name.Local): 17746 val, err := decoder.Value() 17747 if err != nil { 17748 return err 17749 } 17750 if val == nil { 17751 break 17752 } 17753 { 17754 xtv := string(val) 17755 f64, err := strconv.ParseFloat(xtv, 64) 17756 if err != nil { 17757 return err 17758 } 17759 sv.MinIopsPerGib = ptr.Float64(f64) 17760 } 17761 17762 case strings.EqualFold("MinStorageSize", t.Name.Local): 17763 val, err := decoder.Value() 17764 if err != nil { 17765 return err 17766 } 17767 if val == nil { 17768 break 17769 } 17770 { 17771 xtv := string(val) 17772 i64, err := strconv.ParseInt(xtv, 10, 64) 17773 if err != nil { 17774 return err 17775 } 17776 sv.MinStorageSize = ptr.Int32(int32(i64)) 17777 } 17778 17779 case strings.EqualFold("MultiAZCapable", t.Name.Local): 17780 val, err := decoder.Value() 17781 if err != nil { 17782 return err 17783 } 17784 if val == nil { 17785 break 17786 } 17787 { 17788 xtv, err := strconv.ParseBool(string(val)) 17789 if err != nil { 17790 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17791 } 17792 sv.MultiAZCapable = xtv 17793 } 17794 17795 case strings.EqualFold("ReadReplicaCapable", t.Name.Local): 17796 val, err := decoder.Value() 17797 if err != nil { 17798 return err 17799 } 17800 if val == nil { 17801 break 17802 } 17803 { 17804 xtv, err := strconv.ParseBool(string(val)) 17805 if err != nil { 17806 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17807 } 17808 sv.ReadReplicaCapable = xtv 17809 } 17810 17811 case strings.EqualFold("StorageType", t.Name.Local): 17812 val, err := decoder.Value() 17813 if err != nil { 17814 return err 17815 } 17816 if val == nil { 17817 break 17818 } 17819 { 17820 xtv := string(val) 17821 sv.StorageType = ptr.String(xtv) 17822 } 17823 17824 case strings.EqualFold("SupportsEnhancedMonitoring", t.Name.Local): 17825 val, err := decoder.Value() 17826 if err != nil { 17827 return err 17828 } 17829 if val == nil { 17830 break 17831 } 17832 { 17833 xtv, err := strconv.ParseBool(string(val)) 17834 if err != nil { 17835 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17836 } 17837 sv.SupportsEnhancedMonitoring = xtv 17838 } 17839 17840 case strings.EqualFold("SupportsIAMDatabaseAuthentication", t.Name.Local): 17841 val, err := decoder.Value() 17842 if err != nil { 17843 return err 17844 } 17845 if val == nil { 17846 break 17847 } 17848 { 17849 xtv, err := strconv.ParseBool(string(val)) 17850 if err != nil { 17851 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17852 } 17853 sv.SupportsIAMDatabaseAuthentication = xtv 17854 } 17855 17856 case strings.EqualFold("SupportsIops", t.Name.Local): 17857 val, err := decoder.Value() 17858 if err != nil { 17859 return err 17860 } 17861 if val == nil { 17862 break 17863 } 17864 { 17865 xtv, err := strconv.ParseBool(string(val)) 17866 if err != nil { 17867 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17868 } 17869 sv.SupportsIops = xtv 17870 } 17871 17872 case strings.EqualFold("SupportsPerformanceInsights", t.Name.Local): 17873 val, err := decoder.Value() 17874 if err != nil { 17875 return err 17876 } 17877 if val == nil { 17878 break 17879 } 17880 { 17881 xtv, err := strconv.ParseBool(string(val)) 17882 if err != nil { 17883 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17884 } 17885 sv.SupportsPerformanceInsights = xtv 17886 } 17887 17888 case strings.EqualFold("SupportsStorageEncryption", t.Name.Local): 17889 val, err := decoder.Value() 17890 if err != nil { 17891 return err 17892 } 17893 if val == nil { 17894 break 17895 } 17896 { 17897 xtv, err := strconv.ParseBool(string(val)) 17898 if err != nil { 17899 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17900 } 17901 sv.SupportsStorageEncryption = xtv 17902 } 17903 17904 case strings.EqualFold("Vpc", t.Name.Local): 17905 val, err := decoder.Value() 17906 if err != nil { 17907 return err 17908 } 17909 if val == nil { 17910 break 17911 } 17912 { 17913 xtv, err := strconv.ParseBool(string(val)) 17914 if err != nil { 17915 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17916 } 17917 sv.Vpc = xtv 17918 } 17919 17920 default: 17921 // Do nothing and ignore the unexpected tag element 17922 err = decoder.Decoder.Skip() 17923 if err != nil { 17924 return err 17925 } 17926 17927 } 17928 decoder = originalDecoder 17929 } 17930 *v = sv 17931 return nil 17932} 17933 17934func awsAwsquery_deserializeDocumentOrderableDBInstanceOptionsList(v *[]types.OrderableDBInstanceOption, decoder smithyxml.NodeDecoder) error { 17935 if v == nil { 17936 return fmt.Errorf("unexpected nil of type %T", v) 17937 } 17938 var sv []types.OrderableDBInstanceOption 17939 if *v == nil { 17940 sv = make([]types.OrderableDBInstanceOption, 0) 17941 } else { 17942 sv = *v 17943 } 17944 17945 originalDecoder := decoder 17946 for { 17947 t, done, err := decoder.Token() 17948 if err != nil { 17949 return err 17950 } 17951 if done { 17952 break 17953 } 17954 switch { 17955 case strings.EqualFold("OrderableDBInstanceOption", t.Name.Local): 17956 var col types.OrderableDBInstanceOption 17957 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17958 destAddr := &col 17959 if err := awsAwsquery_deserializeDocumentOrderableDBInstanceOption(&destAddr, nodeDecoder); err != nil { 17960 return err 17961 } 17962 col = *destAddr 17963 sv = append(sv, col) 17964 17965 default: 17966 err = decoder.Decoder.Skip() 17967 if err != nil { 17968 return err 17969 } 17970 17971 } 17972 decoder = originalDecoder 17973 } 17974 *v = sv 17975 return nil 17976} 17977 17978func awsAwsquery_deserializeDocumentOrderableDBInstanceOptionsListUnwrapped(v *[]types.OrderableDBInstanceOption, decoder smithyxml.NodeDecoder) error { 17979 var sv []types.OrderableDBInstanceOption 17980 if *v == nil { 17981 sv = make([]types.OrderableDBInstanceOption, 0) 17982 } else { 17983 sv = *v 17984 } 17985 17986 switch { 17987 default: 17988 var mv types.OrderableDBInstanceOption 17989 t := decoder.StartEl 17990 _ = t 17991 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17992 destAddr := &mv 17993 if err := awsAwsquery_deserializeDocumentOrderableDBInstanceOption(&destAddr, nodeDecoder); err != nil { 17994 return err 17995 } 17996 mv = *destAddr 17997 sv = append(sv, mv) 17998 } 17999 *v = sv 18000 return nil 18001} 18002func awsAwsquery_deserializeDocumentParameter(v **types.Parameter, decoder smithyxml.NodeDecoder) error { 18003 if v == nil { 18004 return fmt.Errorf("unexpected nil of type %T", v) 18005 } 18006 var sv *types.Parameter 18007 if *v == nil { 18008 sv = &types.Parameter{} 18009 } else { 18010 sv = *v 18011 } 18012 18013 for { 18014 t, done, err := decoder.Token() 18015 if err != nil { 18016 return err 18017 } 18018 if done { 18019 break 18020 } 18021 originalDecoder := decoder 18022 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18023 switch { 18024 case strings.EqualFold("AllowedValues", t.Name.Local): 18025 val, err := decoder.Value() 18026 if err != nil { 18027 return err 18028 } 18029 if val == nil { 18030 break 18031 } 18032 { 18033 xtv := string(val) 18034 sv.AllowedValues = ptr.String(xtv) 18035 } 18036 18037 case strings.EqualFold("ApplyMethod", t.Name.Local): 18038 val, err := decoder.Value() 18039 if err != nil { 18040 return err 18041 } 18042 if val == nil { 18043 break 18044 } 18045 { 18046 xtv := string(val) 18047 sv.ApplyMethod = types.ApplyMethod(xtv) 18048 } 18049 18050 case strings.EqualFold("ApplyType", t.Name.Local): 18051 val, err := decoder.Value() 18052 if err != nil { 18053 return err 18054 } 18055 if val == nil { 18056 break 18057 } 18058 { 18059 xtv := string(val) 18060 sv.ApplyType = ptr.String(xtv) 18061 } 18062 18063 case strings.EqualFold("DataType", t.Name.Local): 18064 val, err := decoder.Value() 18065 if err != nil { 18066 return err 18067 } 18068 if val == nil { 18069 break 18070 } 18071 { 18072 xtv := string(val) 18073 sv.DataType = ptr.String(xtv) 18074 } 18075 18076 case strings.EqualFold("Description", t.Name.Local): 18077 val, err := decoder.Value() 18078 if err != nil { 18079 return err 18080 } 18081 if val == nil { 18082 break 18083 } 18084 { 18085 xtv := string(val) 18086 sv.Description = ptr.String(xtv) 18087 } 18088 18089 case strings.EqualFold("IsModifiable", t.Name.Local): 18090 val, err := decoder.Value() 18091 if err != nil { 18092 return err 18093 } 18094 if val == nil { 18095 break 18096 } 18097 { 18098 xtv, err := strconv.ParseBool(string(val)) 18099 if err != nil { 18100 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 18101 } 18102 sv.IsModifiable = xtv 18103 } 18104 18105 case strings.EqualFold("MinimumEngineVersion", t.Name.Local): 18106 val, err := decoder.Value() 18107 if err != nil { 18108 return err 18109 } 18110 if val == nil { 18111 break 18112 } 18113 { 18114 xtv := string(val) 18115 sv.MinimumEngineVersion = ptr.String(xtv) 18116 } 18117 18118 case strings.EqualFold("ParameterName", t.Name.Local): 18119 val, err := decoder.Value() 18120 if err != nil { 18121 return err 18122 } 18123 if val == nil { 18124 break 18125 } 18126 { 18127 xtv := string(val) 18128 sv.ParameterName = ptr.String(xtv) 18129 } 18130 18131 case strings.EqualFold("ParameterValue", t.Name.Local): 18132 val, err := decoder.Value() 18133 if err != nil { 18134 return err 18135 } 18136 if val == nil { 18137 break 18138 } 18139 { 18140 xtv := string(val) 18141 sv.ParameterValue = ptr.String(xtv) 18142 } 18143 18144 case strings.EqualFold("Source", t.Name.Local): 18145 val, err := decoder.Value() 18146 if err != nil { 18147 return err 18148 } 18149 if val == nil { 18150 break 18151 } 18152 { 18153 xtv := string(val) 18154 sv.Source = ptr.String(xtv) 18155 } 18156 18157 default: 18158 // Do nothing and ignore the unexpected tag element 18159 err = decoder.Decoder.Skip() 18160 if err != nil { 18161 return err 18162 } 18163 18164 } 18165 decoder = originalDecoder 18166 } 18167 *v = sv 18168 return nil 18169} 18170 18171func awsAwsquery_deserializeDocumentParametersList(v *[]types.Parameter, decoder smithyxml.NodeDecoder) error { 18172 if v == nil { 18173 return fmt.Errorf("unexpected nil of type %T", v) 18174 } 18175 var sv []types.Parameter 18176 if *v == nil { 18177 sv = make([]types.Parameter, 0) 18178 } else { 18179 sv = *v 18180 } 18181 18182 originalDecoder := decoder 18183 for { 18184 t, done, err := decoder.Token() 18185 if err != nil { 18186 return err 18187 } 18188 if done { 18189 break 18190 } 18191 switch { 18192 case strings.EqualFold("Parameter", t.Name.Local): 18193 var col types.Parameter 18194 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18195 destAddr := &col 18196 if err := awsAwsquery_deserializeDocumentParameter(&destAddr, nodeDecoder); err != nil { 18197 return err 18198 } 18199 col = *destAddr 18200 sv = append(sv, col) 18201 18202 default: 18203 err = decoder.Decoder.Skip() 18204 if err != nil { 18205 return err 18206 } 18207 18208 } 18209 decoder = originalDecoder 18210 } 18211 *v = sv 18212 return nil 18213} 18214 18215func awsAwsquery_deserializeDocumentParametersListUnwrapped(v *[]types.Parameter, decoder smithyxml.NodeDecoder) error { 18216 var sv []types.Parameter 18217 if *v == nil { 18218 sv = make([]types.Parameter, 0) 18219 } else { 18220 sv = *v 18221 } 18222 18223 switch { 18224 default: 18225 var mv types.Parameter 18226 t := decoder.StartEl 18227 _ = t 18228 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18229 destAddr := &mv 18230 if err := awsAwsquery_deserializeDocumentParameter(&destAddr, nodeDecoder); err != nil { 18231 return err 18232 } 18233 mv = *destAddr 18234 sv = append(sv, mv) 18235 } 18236 *v = sv 18237 return nil 18238} 18239func awsAwsquery_deserializeDocumentPendingCloudwatchLogsExports(v **types.PendingCloudwatchLogsExports, decoder smithyxml.NodeDecoder) error { 18240 if v == nil { 18241 return fmt.Errorf("unexpected nil of type %T", v) 18242 } 18243 var sv *types.PendingCloudwatchLogsExports 18244 if *v == nil { 18245 sv = &types.PendingCloudwatchLogsExports{} 18246 } else { 18247 sv = *v 18248 } 18249 18250 for { 18251 t, done, err := decoder.Token() 18252 if err != nil { 18253 return err 18254 } 18255 if done { 18256 break 18257 } 18258 originalDecoder := decoder 18259 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18260 switch { 18261 case strings.EqualFold("LogTypesToDisable", t.Name.Local): 18262 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18263 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.LogTypesToDisable, nodeDecoder); err != nil { 18264 return err 18265 } 18266 18267 case strings.EqualFold("LogTypesToEnable", t.Name.Local): 18268 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18269 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.LogTypesToEnable, nodeDecoder); err != nil { 18270 return err 18271 } 18272 18273 default: 18274 // Do nothing and ignore the unexpected tag element 18275 err = decoder.Decoder.Skip() 18276 if err != nil { 18277 return err 18278 } 18279 18280 } 18281 decoder = originalDecoder 18282 } 18283 *v = sv 18284 return nil 18285} 18286 18287func awsAwsquery_deserializeDocumentPendingMaintenanceAction(v **types.PendingMaintenanceAction, decoder smithyxml.NodeDecoder) error { 18288 if v == nil { 18289 return fmt.Errorf("unexpected nil of type %T", v) 18290 } 18291 var sv *types.PendingMaintenanceAction 18292 if *v == nil { 18293 sv = &types.PendingMaintenanceAction{} 18294 } else { 18295 sv = *v 18296 } 18297 18298 for { 18299 t, done, err := decoder.Token() 18300 if err != nil { 18301 return err 18302 } 18303 if done { 18304 break 18305 } 18306 originalDecoder := decoder 18307 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18308 switch { 18309 case strings.EqualFold("Action", t.Name.Local): 18310 val, err := decoder.Value() 18311 if err != nil { 18312 return err 18313 } 18314 if val == nil { 18315 break 18316 } 18317 { 18318 xtv := string(val) 18319 sv.Action = ptr.String(xtv) 18320 } 18321 18322 case strings.EqualFold("AutoAppliedAfterDate", t.Name.Local): 18323 val, err := decoder.Value() 18324 if err != nil { 18325 return err 18326 } 18327 if val == nil { 18328 break 18329 } 18330 { 18331 xtv := string(val) 18332 t, err := smithytime.ParseDateTime(xtv) 18333 if err != nil { 18334 return err 18335 } 18336 sv.AutoAppliedAfterDate = ptr.Time(t) 18337 } 18338 18339 case strings.EqualFold("CurrentApplyDate", t.Name.Local): 18340 val, err := decoder.Value() 18341 if err != nil { 18342 return err 18343 } 18344 if val == nil { 18345 break 18346 } 18347 { 18348 xtv := string(val) 18349 t, err := smithytime.ParseDateTime(xtv) 18350 if err != nil { 18351 return err 18352 } 18353 sv.CurrentApplyDate = ptr.Time(t) 18354 } 18355 18356 case strings.EqualFold("Description", t.Name.Local): 18357 val, err := decoder.Value() 18358 if err != nil { 18359 return err 18360 } 18361 if val == nil { 18362 break 18363 } 18364 { 18365 xtv := string(val) 18366 sv.Description = ptr.String(xtv) 18367 } 18368 18369 case strings.EqualFold("ForcedApplyDate", t.Name.Local): 18370 val, err := decoder.Value() 18371 if err != nil { 18372 return err 18373 } 18374 if val == nil { 18375 break 18376 } 18377 { 18378 xtv := string(val) 18379 t, err := smithytime.ParseDateTime(xtv) 18380 if err != nil { 18381 return err 18382 } 18383 sv.ForcedApplyDate = ptr.Time(t) 18384 } 18385 18386 case strings.EqualFold("OptInStatus", t.Name.Local): 18387 val, err := decoder.Value() 18388 if err != nil { 18389 return err 18390 } 18391 if val == nil { 18392 break 18393 } 18394 { 18395 xtv := string(val) 18396 sv.OptInStatus = ptr.String(xtv) 18397 } 18398 18399 default: 18400 // Do nothing and ignore the unexpected tag element 18401 err = decoder.Decoder.Skip() 18402 if err != nil { 18403 return err 18404 } 18405 18406 } 18407 decoder = originalDecoder 18408 } 18409 *v = sv 18410 return nil 18411} 18412 18413func awsAwsquery_deserializeDocumentPendingMaintenanceActionDetails(v *[]types.PendingMaintenanceAction, decoder smithyxml.NodeDecoder) error { 18414 if v == nil { 18415 return fmt.Errorf("unexpected nil of type %T", v) 18416 } 18417 var sv []types.PendingMaintenanceAction 18418 if *v == nil { 18419 sv = make([]types.PendingMaintenanceAction, 0) 18420 } else { 18421 sv = *v 18422 } 18423 18424 originalDecoder := decoder 18425 for { 18426 t, done, err := decoder.Token() 18427 if err != nil { 18428 return err 18429 } 18430 if done { 18431 break 18432 } 18433 switch { 18434 case strings.EqualFold("PendingMaintenanceAction", t.Name.Local): 18435 var col types.PendingMaintenanceAction 18436 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18437 destAddr := &col 18438 if err := awsAwsquery_deserializeDocumentPendingMaintenanceAction(&destAddr, nodeDecoder); err != nil { 18439 return err 18440 } 18441 col = *destAddr 18442 sv = append(sv, col) 18443 18444 default: 18445 err = decoder.Decoder.Skip() 18446 if err != nil { 18447 return err 18448 } 18449 18450 } 18451 decoder = originalDecoder 18452 } 18453 *v = sv 18454 return nil 18455} 18456 18457func awsAwsquery_deserializeDocumentPendingMaintenanceActionDetailsUnwrapped(v *[]types.PendingMaintenanceAction, decoder smithyxml.NodeDecoder) error { 18458 var sv []types.PendingMaintenanceAction 18459 if *v == nil { 18460 sv = make([]types.PendingMaintenanceAction, 0) 18461 } else { 18462 sv = *v 18463 } 18464 18465 switch { 18466 default: 18467 var mv types.PendingMaintenanceAction 18468 t := decoder.StartEl 18469 _ = t 18470 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18471 destAddr := &mv 18472 if err := awsAwsquery_deserializeDocumentPendingMaintenanceAction(&destAddr, nodeDecoder); err != nil { 18473 return err 18474 } 18475 mv = *destAddr 18476 sv = append(sv, mv) 18477 } 18478 *v = sv 18479 return nil 18480} 18481func awsAwsquery_deserializeDocumentPendingMaintenanceActions(v *[]types.ResourcePendingMaintenanceActions, decoder smithyxml.NodeDecoder) error { 18482 if v == nil { 18483 return fmt.Errorf("unexpected nil of type %T", v) 18484 } 18485 var sv []types.ResourcePendingMaintenanceActions 18486 if *v == nil { 18487 sv = make([]types.ResourcePendingMaintenanceActions, 0) 18488 } else { 18489 sv = *v 18490 } 18491 18492 originalDecoder := decoder 18493 for { 18494 t, done, err := decoder.Token() 18495 if err != nil { 18496 return err 18497 } 18498 if done { 18499 break 18500 } 18501 switch { 18502 case strings.EqualFold("ResourcePendingMaintenanceActions", t.Name.Local): 18503 var col types.ResourcePendingMaintenanceActions 18504 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18505 destAddr := &col 18506 if err := awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(&destAddr, nodeDecoder); err != nil { 18507 return err 18508 } 18509 col = *destAddr 18510 sv = append(sv, col) 18511 18512 default: 18513 err = decoder.Decoder.Skip() 18514 if err != nil { 18515 return err 18516 } 18517 18518 } 18519 decoder = originalDecoder 18520 } 18521 *v = sv 18522 return nil 18523} 18524 18525func awsAwsquery_deserializeDocumentPendingMaintenanceActionsUnwrapped(v *[]types.ResourcePendingMaintenanceActions, decoder smithyxml.NodeDecoder) error { 18526 var sv []types.ResourcePendingMaintenanceActions 18527 if *v == nil { 18528 sv = make([]types.ResourcePendingMaintenanceActions, 0) 18529 } else { 18530 sv = *v 18531 } 18532 18533 switch { 18534 default: 18535 var mv types.ResourcePendingMaintenanceActions 18536 t := decoder.StartEl 18537 _ = t 18538 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18539 destAddr := &mv 18540 if err := awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(&destAddr, nodeDecoder); err != nil { 18541 return err 18542 } 18543 mv = *destAddr 18544 sv = append(sv, mv) 18545 } 18546 *v = sv 18547 return nil 18548} 18549func awsAwsquery_deserializeDocumentPendingModifiedValues(v **types.PendingModifiedValues, decoder smithyxml.NodeDecoder) error { 18550 if v == nil { 18551 return fmt.Errorf("unexpected nil of type %T", v) 18552 } 18553 var sv *types.PendingModifiedValues 18554 if *v == nil { 18555 sv = &types.PendingModifiedValues{} 18556 } else { 18557 sv = *v 18558 } 18559 18560 for { 18561 t, done, err := decoder.Token() 18562 if err != nil { 18563 return err 18564 } 18565 if done { 18566 break 18567 } 18568 originalDecoder := decoder 18569 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18570 switch { 18571 case strings.EqualFold("AllocatedStorage", t.Name.Local): 18572 val, err := decoder.Value() 18573 if err != nil { 18574 return err 18575 } 18576 if val == nil { 18577 break 18578 } 18579 { 18580 xtv := string(val) 18581 i64, err := strconv.ParseInt(xtv, 10, 64) 18582 if err != nil { 18583 return err 18584 } 18585 sv.AllocatedStorage = ptr.Int32(int32(i64)) 18586 } 18587 18588 case strings.EqualFold("BackupRetentionPeriod", t.Name.Local): 18589 val, err := decoder.Value() 18590 if err != nil { 18591 return err 18592 } 18593 if val == nil { 18594 break 18595 } 18596 { 18597 xtv := string(val) 18598 i64, err := strconv.ParseInt(xtv, 10, 64) 18599 if err != nil { 18600 return err 18601 } 18602 sv.BackupRetentionPeriod = ptr.Int32(int32(i64)) 18603 } 18604 18605 case strings.EqualFold("CACertificateIdentifier", t.Name.Local): 18606 val, err := decoder.Value() 18607 if err != nil { 18608 return err 18609 } 18610 if val == nil { 18611 break 18612 } 18613 { 18614 xtv := string(val) 18615 sv.CACertificateIdentifier = ptr.String(xtv) 18616 } 18617 18618 case strings.EqualFold("DBInstanceClass", t.Name.Local): 18619 val, err := decoder.Value() 18620 if err != nil { 18621 return err 18622 } 18623 if val == nil { 18624 break 18625 } 18626 { 18627 xtv := string(val) 18628 sv.DBInstanceClass = ptr.String(xtv) 18629 } 18630 18631 case strings.EqualFold("DBInstanceIdentifier", t.Name.Local): 18632 val, err := decoder.Value() 18633 if err != nil { 18634 return err 18635 } 18636 if val == nil { 18637 break 18638 } 18639 { 18640 xtv := string(val) 18641 sv.DBInstanceIdentifier = ptr.String(xtv) 18642 } 18643 18644 case strings.EqualFold("DBSubnetGroupName", t.Name.Local): 18645 val, err := decoder.Value() 18646 if err != nil { 18647 return err 18648 } 18649 if val == nil { 18650 break 18651 } 18652 { 18653 xtv := string(val) 18654 sv.DBSubnetGroupName = ptr.String(xtv) 18655 } 18656 18657 case strings.EqualFold("EngineVersion", t.Name.Local): 18658 val, err := decoder.Value() 18659 if err != nil { 18660 return err 18661 } 18662 if val == nil { 18663 break 18664 } 18665 { 18666 xtv := string(val) 18667 sv.EngineVersion = ptr.String(xtv) 18668 } 18669 18670 case strings.EqualFold("Iops", t.Name.Local): 18671 val, err := decoder.Value() 18672 if err != nil { 18673 return err 18674 } 18675 if val == nil { 18676 break 18677 } 18678 { 18679 xtv := string(val) 18680 i64, err := strconv.ParseInt(xtv, 10, 64) 18681 if err != nil { 18682 return err 18683 } 18684 sv.Iops = ptr.Int32(int32(i64)) 18685 } 18686 18687 case strings.EqualFold("LicenseModel", t.Name.Local): 18688 val, err := decoder.Value() 18689 if err != nil { 18690 return err 18691 } 18692 if val == nil { 18693 break 18694 } 18695 { 18696 xtv := string(val) 18697 sv.LicenseModel = ptr.String(xtv) 18698 } 18699 18700 case strings.EqualFold("MasterUserPassword", t.Name.Local): 18701 val, err := decoder.Value() 18702 if err != nil { 18703 return err 18704 } 18705 if val == nil { 18706 break 18707 } 18708 { 18709 xtv := string(val) 18710 sv.MasterUserPassword = ptr.String(xtv) 18711 } 18712 18713 case strings.EqualFold("MultiAZ", t.Name.Local): 18714 val, err := decoder.Value() 18715 if err != nil { 18716 return err 18717 } 18718 if val == nil { 18719 break 18720 } 18721 { 18722 xtv, err := strconv.ParseBool(string(val)) 18723 if err != nil { 18724 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 18725 } 18726 sv.MultiAZ = ptr.Bool(xtv) 18727 } 18728 18729 case strings.EqualFold("PendingCloudwatchLogsExports", t.Name.Local): 18730 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18731 if err := awsAwsquery_deserializeDocumentPendingCloudwatchLogsExports(&sv.PendingCloudwatchLogsExports, nodeDecoder); err != nil { 18732 return err 18733 } 18734 18735 case strings.EqualFold("Port", t.Name.Local): 18736 val, err := decoder.Value() 18737 if err != nil { 18738 return err 18739 } 18740 if val == nil { 18741 break 18742 } 18743 { 18744 xtv := string(val) 18745 i64, err := strconv.ParseInt(xtv, 10, 64) 18746 if err != nil { 18747 return err 18748 } 18749 sv.Port = ptr.Int32(int32(i64)) 18750 } 18751 18752 case strings.EqualFold("StorageType", t.Name.Local): 18753 val, err := decoder.Value() 18754 if err != nil { 18755 return err 18756 } 18757 if val == nil { 18758 break 18759 } 18760 { 18761 xtv := string(val) 18762 sv.StorageType = ptr.String(xtv) 18763 } 18764 18765 default: 18766 // Do nothing and ignore the unexpected tag element 18767 err = decoder.Decoder.Skip() 18768 if err != nil { 18769 return err 18770 } 18771 18772 } 18773 decoder = originalDecoder 18774 } 18775 *v = sv 18776 return nil 18777} 18778 18779func awsAwsquery_deserializeDocumentProvisionedIopsNotAvailableInAZFault(v **types.ProvisionedIopsNotAvailableInAZFault, decoder smithyxml.NodeDecoder) error { 18780 if v == nil { 18781 return fmt.Errorf("unexpected nil of type %T", v) 18782 } 18783 var sv *types.ProvisionedIopsNotAvailableInAZFault 18784 if *v == nil { 18785 sv = &types.ProvisionedIopsNotAvailableInAZFault{} 18786 } else { 18787 sv = *v 18788 } 18789 18790 for { 18791 t, done, err := decoder.Token() 18792 if err != nil { 18793 return err 18794 } 18795 if done { 18796 break 18797 } 18798 originalDecoder := decoder 18799 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18800 switch { 18801 case strings.EqualFold("message", t.Name.Local): 18802 val, err := decoder.Value() 18803 if err != nil { 18804 return err 18805 } 18806 if val == nil { 18807 break 18808 } 18809 { 18810 xtv := string(val) 18811 sv.Message = ptr.String(xtv) 18812 } 18813 18814 default: 18815 // Do nothing and ignore the unexpected tag element 18816 err = decoder.Decoder.Skip() 18817 if err != nil { 18818 return err 18819 } 18820 18821 } 18822 decoder = originalDecoder 18823 } 18824 *v = sv 18825 return nil 18826} 18827 18828func awsAwsquery_deserializeDocumentRange(v **types.Range, decoder smithyxml.NodeDecoder) error { 18829 if v == nil { 18830 return fmt.Errorf("unexpected nil of type %T", v) 18831 } 18832 var sv *types.Range 18833 if *v == nil { 18834 sv = &types.Range{} 18835 } else { 18836 sv = *v 18837 } 18838 18839 for { 18840 t, done, err := decoder.Token() 18841 if err != nil { 18842 return err 18843 } 18844 if done { 18845 break 18846 } 18847 originalDecoder := decoder 18848 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18849 switch { 18850 case strings.EqualFold("From", t.Name.Local): 18851 val, err := decoder.Value() 18852 if err != nil { 18853 return err 18854 } 18855 if val == nil { 18856 break 18857 } 18858 { 18859 xtv := string(val) 18860 i64, err := strconv.ParseInt(xtv, 10, 64) 18861 if err != nil { 18862 return err 18863 } 18864 sv.From = int32(i64) 18865 } 18866 18867 case strings.EqualFold("Step", t.Name.Local): 18868 val, err := decoder.Value() 18869 if err != nil { 18870 return err 18871 } 18872 if val == nil { 18873 break 18874 } 18875 { 18876 xtv := string(val) 18877 i64, err := strconv.ParseInt(xtv, 10, 64) 18878 if err != nil { 18879 return err 18880 } 18881 sv.Step = ptr.Int32(int32(i64)) 18882 } 18883 18884 case strings.EqualFold("To", t.Name.Local): 18885 val, err := decoder.Value() 18886 if err != nil { 18887 return err 18888 } 18889 if val == nil { 18890 break 18891 } 18892 { 18893 xtv := string(val) 18894 i64, err := strconv.ParseInt(xtv, 10, 64) 18895 if err != nil { 18896 return err 18897 } 18898 sv.To = int32(i64) 18899 } 18900 18901 default: 18902 // Do nothing and ignore the unexpected tag element 18903 err = decoder.Decoder.Skip() 18904 if err != nil { 18905 return err 18906 } 18907 18908 } 18909 decoder = originalDecoder 18910 } 18911 *v = sv 18912 return nil 18913} 18914 18915func awsAwsquery_deserializeDocumentRangeList(v *[]types.Range, decoder smithyxml.NodeDecoder) error { 18916 if v == nil { 18917 return fmt.Errorf("unexpected nil of type %T", v) 18918 } 18919 var sv []types.Range 18920 if *v == nil { 18921 sv = make([]types.Range, 0) 18922 } else { 18923 sv = *v 18924 } 18925 18926 originalDecoder := decoder 18927 for { 18928 t, done, err := decoder.Token() 18929 if err != nil { 18930 return err 18931 } 18932 if done { 18933 break 18934 } 18935 switch { 18936 case strings.EqualFold("Range", t.Name.Local): 18937 var col types.Range 18938 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18939 destAddr := &col 18940 if err := awsAwsquery_deserializeDocumentRange(&destAddr, nodeDecoder); err != nil { 18941 return err 18942 } 18943 col = *destAddr 18944 sv = append(sv, col) 18945 18946 default: 18947 err = decoder.Decoder.Skip() 18948 if err != nil { 18949 return err 18950 } 18951 18952 } 18953 decoder = originalDecoder 18954 } 18955 *v = sv 18956 return nil 18957} 18958 18959func awsAwsquery_deserializeDocumentRangeListUnwrapped(v *[]types.Range, decoder smithyxml.NodeDecoder) error { 18960 var sv []types.Range 18961 if *v == nil { 18962 sv = make([]types.Range, 0) 18963 } else { 18964 sv = *v 18965 } 18966 18967 switch { 18968 default: 18969 var mv types.Range 18970 t := decoder.StartEl 18971 _ = t 18972 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18973 destAddr := &mv 18974 if err := awsAwsquery_deserializeDocumentRange(&destAddr, nodeDecoder); err != nil { 18975 return err 18976 } 18977 mv = *destAddr 18978 sv = append(sv, mv) 18979 } 18980 *v = sv 18981 return nil 18982} 18983func awsAwsquery_deserializeDocumentReadReplicaDBClusterIdentifierList(v *[]string, decoder smithyxml.NodeDecoder) error { 18984 if v == nil { 18985 return fmt.Errorf("unexpected nil of type %T", v) 18986 } 18987 var sv []string 18988 if *v == nil { 18989 sv = make([]string, 0) 18990 } else { 18991 sv = *v 18992 } 18993 18994 originalDecoder := decoder 18995 for { 18996 t, done, err := decoder.Token() 18997 if err != nil { 18998 return err 18999 } 19000 if done { 19001 break 19002 } 19003 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19004 decoder = memberDecoder 19005 switch { 19006 case strings.EqualFold("ReadReplicaDBClusterIdentifier", t.Name.Local): 19007 var col string 19008 val, err := decoder.Value() 19009 if err != nil { 19010 return err 19011 } 19012 if val == nil { 19013 break 19014 } 19015 { 19016 xtv := string(val) 19017 col = xtv 19018 } 19019 sv = append(sv, col) 19020 19021 default: 19022 err = decoder.Decoder.Skip() 19023 if err != nil { 19024 return err 19025 } 19026 19027 } 19028 decoder = originalDecoder 19029 } 19030 *v = sv 19031 return nil 19032} 19033 19034func awsAwsquery_deserializeDocumentReadReplicaDBClusterIdentifierListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19035 var sv []string 19036 if *v == nil { 19037 sv = make([]string, 0) 19038 } else { 19039 sv = *v 19040 } 19041 19042 switch { 19043 default: 19044 var mv string 19045 t := decoder.StartEl 19046 _ = t 19047 val, err := decoder.Value() 19048 if err != nil { 19049 return err 19050 } 19051 if val == nil { 19052 break 19053 } 19054 { 19055 xtv := string(val) 19056 mv = xtv 19057 } 19058 sv = append(sv, mv) 19059 } 19060 *v = sv 19061 return nil 19062} 19063func awsAwsquery_deserializeDocumentReadReplicaDBInstanceIdentifierList(v *[]string, decoder smithyxml.NodeDecoder) error { 19064 if v == nil { 19065 return fmt.Errorf("unexpected nil of type %T", v) 19066 } 19067 var sv []string 19068 if *v == nil { 19069 sv = make([]string, 0) 19070 } else { 19071 sv = *v 19072 } 19073 19074 originalDecoder := decoder 19075 for { 19076 t, done, err := decoder.Token() 19077 if err != nil { 19078 return err 19079 } 19080 if done { 19081 break 19082 } 19083 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19084 decoder = memberDecoder 19085 switch { 19086 case strings.EqualFold("ReadReplicaDBInstanceIdentifier", t.Name.Local): 19087 var col string 19088 val, err := decoder.Value() 19089 if err != nil { 19090 return err 19091 } 19092 if val == nil { 19093 break 19094 } 19095 { 19096 xtv := string(val) 19097 col = xtv 19098 } 19099 sv = append(sv, col) 19100 19101 default: 19102 err = decoder.Decoder.Skip() 19103 if err != nil { 19104 return err 19105 } 19106 19107 } 19108 decoder = originalDecoder 19109 } 19110 *v = sv 19111 return nil 19112} 19113 19114func awsAwsquery_deserializeDocumentReadReplicaDBInstanceIdentifierListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19115 var sv []string 19116 if *v == nil { 19117 sv = make([]string, 0) 19118 } else { 19119 sv = *v 19120 } 19121 19122 switch { 19123 default: 19124 var mv string 19125 t := decoder.StartEl 19126 _ = t 19127 val, err := decoder.Value() 19128 if err != nil { 19129 return err 19130 } 19131 if val == nil { 19132 break 19133 } 19134 { 19135 xtv := string(val) 19136 mv = xtv 19137 } 19138 sv = append(sv, mv) 19139 } 19140 *v = sv 19141 return nil 19142} 19143func awsAwsquery_deserializeDocumentReadReplicaIdentifierList(v *[]string, decoder smithyxml.NodeDecoder) error { 19144 if v == nil { 19145 return fmt.Errorf("unexpected nil of type %T", v) 19146 } 19147 var sv []string 19148 if *v == nil { 19149 sv = make([]string, 0) 19150 } else { 19151 sv = *v 19152 } 19153 19154 originalDecoder := decoder 19155 for { 19156 t, done, err := decoder.Token() 19157 if err != nil { 19158 return err 19159 } 19160 if done { 19161 break 19162 } 19163 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19164 decoder = memberDecoder 19165 switch { 19166 case strings.EqualFold("ReadReplicaIdentifier", t.Name.Local): 19167 var col string 19168 val, err := decoder.Value() 19169 if err != nil { 19170 return err 19171 } 19172 if val == nil { 19173 break 19174 } 19175 { 19176 xtv := string(val) 19177 col = xtv 19178 } 19179 sv = append(sv, col) 19180 19181 default: 19182 err = decoder.Decoder.Skip() 19183 if err != nil { 19184 return err 19185 } 19186 19187 } 19188 decoder = originalDecoder 19189 } 19190 *v = sv 19191 return nil 19192} 19193 19194func awsAwsquery_deserializeDocumentReadReplicaIdentifierListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19195 var sv []string 19196 if *v == nil { 19197 sv = make([]string, 0) 19198 } else { 19199 sv = *v 19200 } 19201 19202 switch { 19203 default: 19204 var mv string 19205 t := decoder.StartEl 19206 _ = t 19207 val, err := decoder.Value() 19208 if err != nil { 19209 return err 19210 } 19211 if val == nil { 19212 break 19213 } 19214 { 19215 xtv := string(val) 19216 mv = xtv 19217 } 19218 sv = append(sv, mv) 19219 } 19220 *v = sv 19221 return nil 19222} 19223func awsAwsquery_deserializeDocumentResourceNotFoundFault(v **types.ResourceNotFoundFault, decoder smithyxml.NodeDecoder) error { 19224 if v == nil { 19225 return fmt.Errorf("unexpected nil of type %T", v) 19226 } 19227 var sv *types.ResourceNotFoundFault 19228 if *v == nil { 19229 sv = &types.ResourceNotFoundFault{} 19230 } else { 19231 sv = *v 19232 } 19233 19234 for { 19235 t, done, err := decoder.Token() 19236 if err != nil { 19237 return err 19238 } 19239 if done { 19240 break 19241 } 19242 originalDecoder := decoder 19243 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19244 switch { 19245 case strings.EqualFold("message", t.Name.Local): 19246 val, err := decoder.Value() 19247 if err != nil { 19248 return err 19249 } 19250 if val == nil { 19251 break 19252 } 19253 { 19254 xtv := string(val) 19255 sv.Message = ptr.String(xtv) 19256 } 19257 19258 default: 19259 // Do nothing and ignore the unexpected tag element 19260 err = decoder.Decoder.Skip() 19261 if err != nil { 19262 return err 19263 } 19264 19265 } 19266 decoder = originalDecoder 19267 } 19268 *v = sv 19269 return nil 19270} 19271 19272func awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(v **types.ResourcePendingMaintenanceActions, decoder smithyxml.NodeDecoder) error { 19273 if v == nil { 19274 return fmt.Errorf("unexpected nil of type %T", v) 19275 } 19276 var sv *types.ResourcePendingMaintenanceActions 19277 if *v == nil { 19278 sv = &types.ResourcePendingMaintenanceActions{} 19279 } else { 19280 sv = *v 19281 } 19282 19283 for { 19284 t, done, err := decoder.Token() 19285 if err != nil { 19286 return err 19287 } 19288 if done { 19289 break 19290 } 19291 originalDecoder := decoder 19292 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19293 switch { 19294 case strings.EqualFold("PendingMaintenanceActionDetails", t.Name.Local): 19295 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19296 if err := awsAwsquery_deserializeDocumentPendingMaintenanceActionDetails(&sv.PendingMaintenanceActionDetails, nodeDecoder); err != nil { 19297 return err 19298 } 19299 19300 case strings.EqualFold("ResourceIdentifier", t.Name.Local): 19301 val, err := decoder.Value() 19302 if err != nil { 19303 return err 19304 } 19305 if val == nil { 19306 break 19307 } 19308 { 19309 xtv := string(val) 19310 sv.ResourceIdentifier = ptr.String(xtv) 19311 } 19312 19313 default: 19314 // Do nothing and ignore the unexpected tag element 19315 err = decoder.Decoder.Skip() 19316 if err != nil { 19317 return err 19318 } 19319 19320 } 19321 decoder = originalDecoder 19322 } 19323 *v = sv 19324 return nil 19325} 19326 19327func awsAwsquery_deserializeDocumentSharedSnapshotQuotaExceededFault(v **types.SharedSnapshotQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 19328 if v == nil { 19329 return fmt.Errorf("unexpected nil of type %T", v) 19330 } 19331 var sv *types.SharedSnapshotQuotaExceededFault 19332 if *v == nil { 19333 sv = &types.SharedSnapshotQuotaExceededFault{} 19334 } else { 19335 sv = *v 19336 } 19337 19338 for { 19339 t, done, err := decoder.Token() 19340 if err != nil { 19341 return err 19342 } 19343 if done { 19344 break 19345 } 19346 originalDecoder := decoder 19347 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19348 switch { 19349 case strings.EqualFold("message", t.Name.Local): 19350 val, err := decoder.Value() 19351 if err != nil { 19352 return err 19353 } 19354 if val == nil { 19355 break 19356 } 19357 { 19358 xtv := string(val) 19359 sv.Message = ptr.String(xtv) 19360 } 19361 19362 default: 19363 // Do nothing and ignore the unexpected tag element 19364 err = decoder.Decoder.Skip() 19365 if err != nil { 19366 return err 19367 } 19368 19369 } 19370 decoder = originalDecoder 19371 } 19372 *v = sv 19373 return nil 19374} 19375 19376func awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(v **types.SnapshotQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 19377 if v == nil { 19378 return fmt.Errorf("unexpected nil of type %T", v) 19379 } 19380 var sv *types.SnapshotQuotaExceededFault 19381 if *v == nil { 19382 sv = &types.SnapshotQuotaExceededFault{} 19383 } else { 19384 sv = *v 19385 } 19386 19387 for { 19388 t, done, err := decoder.Token() 19389 if err != nil { 19390 return err 19391 } 19392 if done { 19393 break 19394 } 19395 originalDecoder := decoder 19396 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19397 switch { 19398 case strings.EqualFold("message", t.Name.Local): 19399 val, err := decoder.Value() 19400 if err != nil { 19401 return err 19402 } 19403 if val == nil { 19404 break 19405 } 19406 { 19407 xtv := string(val) 19408 sv.Message = ptr.String(xtv) 19409 } 19410 19411 default: 19412 // Do nothing and ignore the unexpected tag element 19413 err = decoder.Decoder.Skip() 19414 if err != nil { 19415 return err 19416 } 19417 19418 } 19419 decoder = originalDecoder 19420 } 19421 *v = sv 19422 return nil 19423} 19424 19425func awsAwsquery_deserializeDocumentSNSInvalidTopicFault(v **types.SNSInvalidTopicFault, decoder smithyxml.NodeDecoder) error { 19426 if v == nil { 19427 return fmt.Errorf("unexpected nil of type %T", v) 19428 } 19429 var sv *types.SNSInvalidTopicFault 19430 if *v == nil { 19431 sv = &types.SNSInvalidTopicFault{} 19432 } else { 19433 sv = *v 19434 } 19435 19436 for { 19437 t, done, err := decoder.Token() 19438 if err != nil { 19439 return err 19440 } 19441 if done { 19442 break 19443 } 19444 originalDecoder := decoder 19445 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19446 switch { 19447 case strings.EqualFold("message", t.Name.Local): 19448 val, err := decoder.Value() 19449 if err != nil { 19450 return err 19451 } 19452 if val == nil { 19453 break 19454 } 19455 { 19456 xtv := string(val) 19457 sv.Message = ptr.String(xtv) 19458 } 19459 19460 default: 19461 // Do nothing and ignore the unexpected tag element 19462 err = decoder.Decoder.Skip() 19463 if err != nil { 19464 return err 19465 } 19466 19467 } 19468 decoder = originalDecoder 19469 } 19470 *v = sv 19471 return nil 19472} 19473 19474func awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(v **types.SNSNoAuthorizationFault, decoder smithyxml.NodeDecoder) error { 19475 if v == nil { 19476 return fmt.Errorf("unexpected nil of type %T", v) 19477 } 19478 var sv *types.SNSNoAuthorizationFault 19479 if *v == nil { 19480 sv = &types.SNSNoAuthorizationFault{} 19481 } else { 19482 sv = *v 19483 } 19484 19485 for { 19486 t, done, err := decoder.Token() 19487 if err != nil { 19488 return err 19489 } 19490 if done { 19491 break 19492 } 19493 originalDecoder := decoder 19494 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19495 switch { 19496 case strings.EqualFold("message", t.Name.Local): 19497 val, err := decoder.Value() 19498 if err != nil { 19499 return err 19500 } 19501 if val == nil { 19502 break 19503 } 19504 { 19505 xtv := string(val) 19506 sv.Message = ptr.String(xtv) 19507 } 19508 19509 default: 19510 // Do nothing and ignore the unexpected tag element 19511 err = decoder.Decoder.Skip() 19512 if err != nil { 19513 return err 19514 } 19515 19516 } 19517 decoder = originalDecoder 19518 } 19519 *v = sv 19520 return nil 19521} 19522 19523func awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(v **types.SNSTopicArnNotFoundFault, decoder smithyxml.NodeDecoder) error { 19524 if v == nil { 19525 return fmt.Errorf("unexpected nil of type %T", v) 19526 } 19527 var sv *types.SNSTopicArnNotFoundFault 19528 if *v == nil { 19529 sv = &types.SNSTopicArnNotFoundFault{} 19530 } else { 19531 sv = *v 19532 } 19533 19534 for { 19535 t, done, err := decoder.Token() 19536 if err != nil { 19537 return err 19538 } 19539 if done { 19540 break 19541 } 19542 originalDecoder := decoder 19543 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19544 switch { 19545 case strings.EqualFold("message", t.Name.Local): 19546 val, err := decoder.Value() 19547 if err != nil { 19548 return err 19549 } 19550 if val == nil { 19551 break 19552 } 19553 { 19554 xtv := string(val) 19555 sv.Message = ptr.String(xtv) 19556 } 19557 19558 default: 19559 // Do nothing and ignore the unexpected tag element 19560 err = decoder.Decoder.Skip() 19561 if err != nil { 19562 return err 19563 } 19564 19565 } 19566 decoder = originalDecoder 19567 } 19568 *v = sv 19569 return nil 19570} 19571 19572func awsAwsquery_deserializeDocumentSourceIdsList(v *[]string, decoder smithyxml.NodeDecoder) error { 19573 if v == nil { 19574 return fmt.Errorf("unexpected nil of type %T", v) 19575 } 19576 var sv []string 19577 if *v == nil { 19578 sv = make([]string, 0) 19579 } else { 19580 sv = *v 19581 } 19582 19583 originalDecoder := decoder 19584 for { 19585 t, done, err := decoder.Token() 19586 if err != nil { 19587 return err 19588 } 19589 if done { 19590 break 19591 } 19592 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19593 decoder = memberDecoder 19594 switch { 19595 case strings.EqualFold("SourceId", t.Name.Local): 19596 var col string 19597 val, err := decoder.Value() 19598 if err != nil { 19599 return err 19600 } 19601 if val == nil { 19602 break 19603 } 19604 { 19605 xtv := string(val) 19606 col = xtv 19607 } 19608 sv = append(sv, col) 19609 19610 default: 19611 err = decoder.Decoder.Skip() 19612 if err != nil { 19613 return err 19614 } 19615 19616 } 19617 decoder = originalDecoder 19618 } 19619 *v = sv 19620 return nil 19621} 19622 19623func awsAwsquery_deserializeDocumentSourceIdsListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19624 var sv []string 19625 if *v == nil { 19626 sv = make([]string, 0) 19627 } else { 19628 sv = *v 19629 } 19630 19631 switch { 19632 default: 19633 var mv string 19634 t := decoder.StartEl 19635 _ = t 19636 val, err := decoder.Value() 19637 if err != nil { 19638 return err 19639 } 19640 if val == nil { 19641 break 19642 } 19643 { 19644 xtv := string(val) 19645 mv = xtv 19646 } 19647 sv = append(sv, mv) 19648 } 19649 *v = sv 19650 return nil 19651} 19652func awsAwsquery_deserializeDocumentSourceNotFoundFault(v **types.SourceNotFoundFault, decoder smithyxml.NodeDecoder) error { 19653 if v == nil { 19654 return fmt.Errorf("unexpected nil of type %T", v) 19655 } 19656 var sv *types.SourceNotFoundFault 19657 if *v == nil { 19658 sv = &types.SourceNotFoundFault{} 19659 } else { 19660 sv = *v 19661 } 19662 19663 for { 19664 t, done, err := decoder.Token() 19665 if err != nil { 19666 return err 19667 } 19668 if done { 19669 break 19670 } 19671 originalDecoder := decoder 19672 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19673 switch { 19674 case strings.EqualFold("message", t.Name.Local): 19675 val, err := decoder.Value() 19676 if err != nil { 19677 return err 19678 } 19679 if val == nil { 19680 break 19681 } 19682 { 19683 xtv := string(val) 19684 sv.Message = ptr.String(xtv) 19685 } 19686 19687 default: 19688 // Do nothing and ignore the unexpected tag element 19689 err = decoder.Decoder.Skip() 19690 if err != nil { 19691 return err 19692 } 19693 19694 } 19695 decoder = originalDecoder 19696 } 19697 *v = sv 19698 return nil 19699} 19700 19701func awsAwsquery_deserializeDocumentStorageQuotaExceededFault(v **types.StorageQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 19702 if v == nil { 19703 return fmt.Errorf("unexpected nil of type %T", v) 19704 } 19705 var sv *types.StorageQuotaExceededFault 19706 if *v == nil { 19707 sv = &types.StorageQuotaExceededFault{} 19708 } else { 19709 sv = *v 19710 } 19711 19712 for { 19713 t, done, err := decoder.Token() 19714 if err != nil { 19715 return err 19716 } 19717 if done { 19718 break 19719 } 19720 originalDecoder := decoder 19721 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19722 switch { 19723 case strings.EqualFold("message", t.Name.Local): 19724 val, err := decoder.Value() 19725 if err != nil { 19726 return err 19727 } 19728 if val == nil { 19729 break 19730 } 19731 { 19732 xtv := string(val) 19733 sv.Message = ptr.String(xtv) 19734 } 19735 19736 default: 19737 // Do nothing and ignore the unexpected tag element 19738 err = decoder.Decoder.Skip() 19739 if err != nil { 19740 return err 19741 } 19742 19743 } 19744 decoder = originalDecoder 19745 } 19746 *v = sv 19747 return nil 19748} 19749 19750func awsAwsquery_deserializeDocumentStorageTypeNotSupportedFault(v **types.StorageTypeNotSupportedFault, decoder smithyxml.NodeDecoder) error { 19751 if v == nil { 19752 return fmt.Errorf("unexpected nil of type %T", v) 19753 } 19754 var sv *types.StorageTypeNotSupportedFault 19755 if *v == nil { 19756 sv = &types.StorageTypeNotSupportedFault{} 19757 } else { 19758 sv = *v 19759 } 19760 19761 for { 19762 t, done, err := decoder.Token() 19763 if err != nil { 19764 return err 19765 } 19766 if done { 19767 break 19768 } 19769 originalDecoder := decoder 19770 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19771 switch { 19772 case strings.EqualFold("message", t.Name.Local): 19773 val, err := decoder.Value() 19774 if err != nil { 19775 return err 19776 } 19777 if val == nil { 19778 break 19779 } 19780 { 19781 xtv := string(val) 19782 sv.Message = ptr.String(xtv) 19783 } 19784 19785 default: 19786 // Do nothing and ignore the unexpected tag element 19787 err = decoder.Decoder.Skip() 19788 if err != nil { 19789 return err 19790 } 19791 19792 } 19793 decoder = originalDecoder 19794 } 19795 *v = sv 19796 return nil 19797} 19798 19799func awsAwsquery_deserializeDocumentStringList(v *[]string, decoder smithyxml.NodeDecoder) error { 19800 if v == nil { 19801 return fmt.Errorf("unexpected nil of type %T", v) 19802 } 19803 var sv []string 19804 if *v == nil { 19805 sv = make([]string, 0) 19806 } else { 19807 sv = *v 19808 } 19809 19810 originalDecoder := decoder 19811 for { 19812 t, done, err := decoder.Token() 19813 if err != nil { 19814 return err 19815 } 19816 if done { 19817 break 19818 } 19819 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19820 decoder = memberDecoder 19821 switch { 19822 case strings.EqualFold("member", t.Name.Local): 19823 var col string 19824 val, err := decoder.Value() 19825 if err != nil { 19826 return err 19827 } 19828 if val == nil { 19829 break 19830 } 19831 { 19832 xtv := string(val) 19833 col = xtv 19834 } 19835 sv = append(sv, col) 19836 19837 default: 19838 err = decoder.Decoder.Skip() 19839 if err != nil { 19840 return err 19841 } 19842 19843 } 19844 decoder = originalDecoder 19845 } 19846 *v = sv 19847 return nil 19848} 19849 19850func awsAwsquery_deserializeDocumentStringListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19851 var sv []string 19852 if *v == nil { 19853 sv = make([]string, 0) 19854 } else { 19855 sv = *v 19856 } 19857 19858 switch { 19859 default: 19860 var mv string 19861 t := decoder.StartEl 19862 _ = t 19863 val, err := decoder.Value() 19864 if err != nil { 19865 return err 19866 } 19867 if val == nil { 19868 break 19869 } 19870 { 19871 xtv := string(val) 19872 mv = xtv 19873 } 19874 sv = append(sv, mv) 19875 } 19876 *v = sv 19877 return nil 19878} 19879func awsAwsquery_deserializeDocumentSubnet(v **types.Subnet, decoder smithyxml.NodeDecoder) error { 19880 if v == nil { 19881 return fmt.Errorf("unexpected nil of type %T", v) 19882 } 19883 var sv *types.Subnet 19884 if *v == nil { 19885 sv = &types.Subnet{} 19886 } else { 19887 sv = *v 19888 } 19889 19890 for { 19891 t, done, err := decoder.Token() 19892 if err != nil { 19893 return err 19894 } 19895 if done { 19896 break 19897 } 19898 originalDecoder := decoder 19899 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19900 switch { 19901 case strings.EqualFold("SubnetAvailabilityZone", t.Name.Local): 19902 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19903 if err := awsAwsquery_deserializeDocumentAvailabilityZone(&sv.SubnetAvailabilityZone, nodeDecoder); err != nil { 19904 return err 19905 } 19906 19907 case strings.EqualFold("SubnetIdentifier", t.Name.Local): 19908 val, err := decoder.Value() 19909 if err != nil { 19910 return err 19911 } 19912 if val == nil { 19913 break 19914 } 19915 { 19916 xtv := string(val) 19917 sv.SubnetIdentifier = ptr.String(xtv) 19918 } 19919 19920 case strings.EqualFold("SubnetStatus", t.Name.Local): 19921 val, err := decoder.Value() 19922 if err != nil { 19923 return err 19924 } 19925 if val == nil { 19926 break 19927 } 19928 { 19929 xtv := string(val) 19930 sv.SubnetStatus = ptr.String(xtv) 19931 } 19932 19933 default: 19934 // Do nothing and ignore the unexpected tag element 19935 err = decoder.Decoder.Skip() 19936 if err != nil { 19937 return err 19938 } 19939 19940 } 19941 decoder = originalDecoder 19942 } 19943 *v = sv 19944 return nil 19945} 19946 19947func awsAwsquery_deserializeDocumentSubnetAlreadyInUse(v **types.SubnetAlreadyInUse, decoder smithyxml.NodeDecoder) error { 19948 if v == nil { 19949 return fmt.Errorf("unexpected nil of type %T", v) 19950 } 19951 var sv *types.SubnetAlreadyInUse 19952 if *v == nil { 19953 sv = &types.SubnetAlreadyInUse{} 19954 } else { 19955 sv = *v 19956 } 19957 19958 for { 19959 t, done, err := decoder.Token() 19960 if err != nil { 19961 return err 19962 } 19963 if done { 19964 break 19965 } 19966 originalDecoder := decoder 19967 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19968 switch { 19969 case strings.EqualFold("message", t.Name.Local): 19970 val, err := decoder.Value() 19971 if err != nil { 19972 return err 19973 } 19974 if val == nil { 19975 break 19976 } 19977 { 19978 xtv := string(val) 19979 sv.Message = ptr.String(xtv) 19980 } 19981 19982 default: 19983 // Do nothing and ignore the unexpected tag element 19984 err = decoder.Decoder.Skip() 19985 if err != nil { 19986 return err 19987 } 19988 19989 } 19990 decoder = originalDecoder 19991 } 19992 *v = sv 19993 return nil 19994} 19995 19996func awsAwsquery_deserializeDocumentSubnetList(v *[]types.Subnet, decoder smithyxml.NodeDecoder) error { 19997 if v == nil { 19998 return fmt.Errorf("unexpected nil of type %T", v) 19999 } 20000 var sv []types.Subnet 20001 if *v == nil { 20002 sv = make([]types.Subnet, 0) 20003 } else { 20004 sv = *v 20005 } 20006 20007 originalDecoder := decoder 20008 for { 20009 t, done, err := decoder.Token() 20010 if err != nil { 20011 return err 20012 } 20013 if done { 20014 break 20015 } 20016 switch { 20017 case strings.EqualFold("Subnet", t.Name.Local): 20018 var col types.Subnet 20019 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20020 destAddr := &col 20021 if err := awsAwsquery_deserializeDocumentSubnet(&destAddr, nodeDecoder); err != nil { 20022 return err 20023 } 20024 col = *destAddr 20025 sv = append(sv, col) 20026 20027 default: 20028 err = decoder.Decoder.Skip() 20029 if err != nil { 20030 return err 20031 } 20032 20033 } 20034 decoder = originalDecoder 20035 } 20036 *v = sv 20037 return nil 20038} 20039 20040func awsAwsquery_deserializeDocumentSubnetListUnwrapped(v *[]types.Subnet, decoder smithyxml.NodeDecoder) error { 20041 var sv []types.Subnet 20042 if *v == nil { 20043 sv = make([]types.Subnet, 0) 20044 } else { 20045 sv = *v 20046 } 20047 20048 switch { 20049 default: 20050 var mv types.Subnet 20051 t := decoder.StartEl 20052 _ = t 20053 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20054 destAddr := &mv 20055 if err := awsAwsquery_deserializeDocumentSubnet(&destAddr, nodeDecoder); err != nil { 20056 return err 20057 } 20058 mv = *destAddr 20059 sv = append(sv, mv) 20060 } 20061 *v = sv 20062 return nil 20063} 20064func awsAwsquery_deserializeDocumentSubscriptionAlreadyExistFault(v **types.SubscriptionAlreadyExistFault, decoder smithyxml.NodeDecoder) error { 20065 if v == nil { 20066 return fmt.Errorf("unexpected nil of type %T", v) 20067 } 20068 var sv *types.SubscriptionAlreadyExistFault 20069 if *v == nil { 20070 sv = &types.SubscriptionAlreadyExistFault{} 20071 } else { 20072 sv = *v 20073 } 20074 20075 for { 20076 t, done, err := decoder.Token() 20077 if err != nil { 20078 return err 20079 } 20080 if done { 20081 break 20082 } 20083 originalDecoder := decoder 20084 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20085 switch { 20086 case strings.EqualFold("message", t.Name.Local): 20087 val, err := decoder.Value() 20088 if err != nil { 20089 return err 20090 } 20091 if val == nil { 20092 break 20093 } 20094 { 20095 xtv := string(val) 20096 sv.Message = ptr.String(xtv) 20097 } 20098 20099 default: 20100 // Do nothing and ignore the unexpected tag element 20101 err = decoder.Decoder.Skip() 20102 if err != nil { 20103 return err 20104 } 20105 20106 } 20107 decoder = originalDecoder 20108 } 20109 *v = sv 20110 return nil 20111} 20112 20113func awsAwsquery_deserializeDocumentSubscriptionCategoryNotFoundFault(v **types.SubscriptionCategoryNotFoundFault, decoder smithyxml.NodeDecoder) error { 20114 if v == nil { 20115 return fmt.Errorf("unexpected nil of type %T", v) 20116 } 20117 var sv *types.SubscriptionCategoryNotFoundFault 20118 if *v == nil { 20119 sv = &types.SubscriptionCategoryNotFoundFault{} 20120 } else { 20121 sv = *v 20122 } 20123 20124 for { 20125 t, done, err := decoder.Token() 20126 if err != nil { 20127 return err 20128 } 20129 if done { 20130 break 20131 } 20132 originalDecoder := decoder 20133 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20134 switch { 20135 case strings.EqualFold("message", t.Name.Local): 20136 val, err := decoder.Value() 20137 if err != nil { 20138 return err 20139 } 20140 if val == nil { 20141 break 20142 } 20143 { 20144 xtv := string(val) 20145 sv.Message = ptr.String(xtv) 20146 } 20147 20148 default: 20149 // Do nothing and ignore the unexpected tag element 20150 err = decoder.Decoder.Skip() 20151 if err != nil { 20152 return err 20153 } 20154 20155 } 20156 decoder = originalDecoder 20157 } 20158 *v = sv 20159 return nil 20160} 20161 20162func awsAwsquery_deserializeDocumentSubscriptionNotFoundFault(v **types.SubscriptionNotFoundFault, decoder smithyxml.NodeDecoder) error { 20163 if v == nil { 20164 return fmt.Errorf("unexpected nil of type %T", v) 20165 } 20166 var sv *types.SubscriptionNotFoundFault 20167 if *v == nil { 20168 sv = &types.SubscriptionNotFoundFault{} 20169 } else { 20170 sv = *v 20171 } 20172 20173 for { 20174 t, done, err := decoder.Token() 20175 if err != nil { 20176 return err 20177 } 20178 if done { 20179 break 20180 } 20181 originalDecoder := decoder 20182 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20183 switch { 20184 case strings.EqualFold("message", t.Name.Local): 20185 val, err := decoder.Value() 20186 if err != nil { 20187 return err 20188 } 20189 if val == nil { 20190 break 20191 } 20192 { 20193 xtv := string(val) 20194 sv.Message = ptr.String(xtv) 20195 } 20196 20197 default: 20198 // Do nothing and ignore the unexpected tag element 20199 err = decoder.Decoder.Skip() 20200 if err != nil { 20201 return err 20202 } 20203 20204 } 20205 decoder = originalDecoder 20206 } 20207 *v = sv 20208 return nil 20209} 20210 20211func awsAwsquery_deserializeDocumentSupportedCharacterSetsList(v *[]types.CharacterSet, decoder smithyxml.NodeDecoder) error { 20212 if v == nil { 20213 return fmt.Errorf("unexpected nil of type %T", v) 20214 } 20215 var sv []types.CharacterSet 20216 if *v == nil { 20217 sv = make([]types.CharacterSet, 0) 20218 } else { 20219 sv = *v 20220 } 20221 20222 originalDecoder := decoder 20223 for { 20224 t, done, err := decoder.Token() 20225 if err != nil { 20226 return err 20227 } 20228 if done { 20229 break 20230 } 20231 switch { 20232 case strings.EqualFold("CharacterSet", t.Name.Local): 20233 var col types.CharacterSet 20234 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20235 destAddr := &col 20236 if err := awsAwsquery_deserializeDocumentCharacterSet(&destAddr, nodeDecoder); err != nil { 20237 return err 20238 } 20239 col = *destAddr 20240 sv = append(sv, col) 20241 20242 default: 20243 err = decoder.Decoder.Skip() 20244 if err != nil { 20245 return err 20246 } 20247 20248 } 20249 decoder = originalDecoder 20250 } 20251 *v = sv 20252 return nil 20253} 20254 20255func awsAwsquery_deserializeDocumentSupportedCharacterSetsListUnwrapped(v *[]types.CharacterSet, decoder smithyxml.NodeDecoder) error { 20256 var sv []types.CharacterSet 20257 if *v == nil { 20258 sv = make([]types.CharacterSet, 0) 20259 } else { 20260 sv = *v 20261 } 20262 20263 switch { 20264 default: 20265 var mv types.CharacterSet 20266 t := decoder.StartEl 20267 _ = t 20268 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20269 destAddr := &mv 20270 if err := awsAwsquery_deserializeDocumentCharacterSet(&destAddr, nodeDecoder); err != nil { 20271 return err 20272 } 20273 mv = *destAddr 20274 sv = append(sv, mv) 20275 } 20276 *v = sv 20277 return nil 20278} 20279func awsAwsquery_deserializeDocumentSupportedTimezonesList(v *[]types.Timezone, decoder smithyxml.NodeDecoder) error { 20280 if v == nil { 20281 return fmt.Errorf("unexpected nil of type %T", v) 20282 } 20283 var sv []types.Timezone 20284 if *v == nil { 20285 sv = make([]types.Timezone, 0) 20286 } else { 20287 sv = *v 20288 } 20289 20290 originalDecoder := decoder 20291 for { 20292 t, done, err := decoder.Token() 20293 if err != nil { 20294 return err 20295 } 20296 if done { 20297 break 20298 } 20299 switch { 20300 case strings.EqualFold("Timezone", t.Name.Local): 20301 var col types.Timezone 20302 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20303 destAddr := &col 20304 if err := awsAwsquery_deserializeDocumentTimezone(&destAddr, nodeDecoder); err != nil { 20305 return err 20306 } 20307 col = *destAddr 20308 sv = append(sv, col) 20309 20310 default: 20311 err = decoder.Decoder.Skip() 20312 if err != nil { 20313 return err 20314 } 20315 20316 } 20317 decoder = originalDecoder 20318 } 20319 *v = sv 20320 return nil 20321} 20322 20323func awsAwsquery_deserializeDocumentSupportedTimezonesListUnwrapped(v *[]types.Timezone, decoder smithyxml.NodeDecoder) error { 20324 var sv []types.Timezone 20325 if *v == nil { 20326 sv = make([]types.Timezone, 0) 20327 } else { 20328 sv = *v 20329 } 20330 20331 switch { 20332 default: 20333 var mv types.Timezone 20334 t := decoder.StartEl 20335 _ = t 20336 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20337 destAddr := &mv 20338 if err := awsAwsquery_deserializeDocumentTimezone(&destAddr, nodeDecoder); err != nil { 20339 return err 20340 } 20341 mv = *destAddr 20342 sv = append(sv, mv) 20343 } 20344 *v = sv 20345 return nil 20346} 20347func awsAwsquery_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error { 20348 if v == nil { 20349 return fmt.Errorf("unexpected nil of type %T", v) 20350 } 20351 var sv *types.Tag 20352 if *v == nil { 20353 sv = &types.Tag{} 20354 } else { 20355 sv = *v 20356 } 20357 20358 for { 20359 t, done, err := decoder.Token() 20360 if err != nil { 20361 return err 20362 } 20363 if done { 20364 break 20365 } 20366 originalDecoder := decoder 20367 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20368 switch { 20369 case strings.EqualFold("Key", t.Name.Local): 20370 val, err := decoder.Value() 20371 if err != nil { 20372 return err 20373 } 20374 if val == nil { 20375 break 20376 } 20377 { 20378 xtv := string(val) 20379 sv.Key = ptr.String(xtv) 20380 } 20381 20382 case strings.EqualFold("Value", t.Name.Local): 20383 val, err := decoder.Value() 20384 if err != nil { 20385 return err 20386 } 20387 if val == nil { 20388 break 20389 } 20390 { 20391 xtv := string(val) 20392 sv.Value = ptr.String(xtv) 20393 } 20394 20395 default: 20396 // Do nothing and ignore the unexpected tag element 20397 err = decoder.Decoder.Skip() 20398 if err != nil { 20399 return err 20400 } 20401 20402 } 20403 decoder = originalDecoder 20404 } 20405 *v = sv 20406 return nil 20407} 20408 20409func awsAwsquery_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 20410 if v == nil { 20411 return fmt.Errorf("unexpected nil of type %T", v) 20412 } 20413 var sv []types.Tag 20414 if *v == nil { 20415 sv = make([]types.Tag, 0) 20416 } else { 20417 sv = *v 20418 } 20419 20420 originalDecoder := decoder 20421 for { 20422 t, done, err := decoder.Token() 20423 if err != nil { 20424 return err 20425 } 20426 if done { 20427 break 20428 } 20429 switch { 20430 case strings.EqualFold("Tag", t.Name.Local): 20431 var col types.Tag 20432 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20433 destAddr := &col 20434 if err := awsAwsquery_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 20435 return err 20436 } 20437 col = *destAddr 20438 sv = append(sv, col) 20439 20440 default: 20441 err = decoder.Decoder.Skip() 20442 if err != nil { 20443 return err 20444 } 20445 20446 } 20447 decoder = originalDecoder 20448 } 20449 *v = sv 20450 return nil 20451} 20452 20453func awsAwsquery_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 20454 var sv []types.Tag 20455 if *v == nil { 20456 sv = make([]types.Tag, 0) 20457 } else { 20458 sv = *v 20459 } 20460 20461 switch { 20462 default: 20463 var mv types.Tag 20464 t := decoder.StartEl 20465 _ = t 20466 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20467 destAddr := &mv 20468 if err := awsAwsquery_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 20469 return err 20470 } 20471 mv = *destAddr 20472 sv = append(sv, mv) 20473 } 20474 *v = sv 20475 return nil 20476} 20477func awsAwsquery_deserializeDocumentTimezone(v **types.Timezone, decoder smithyxml.NodeDecoder) error { 20478 if v == nil { 20479 return fmt.Errorf("unexpected nil of type %T", v) 20480 } 20481 var sv *types.Timezone 20482 if *v == nil { 20483 sv = &types.Timezone{} 20484 } else { 20485 sv = *v 20486 } 20487 20488 for { 20489 t, done, err := decoder.Token() 20490 if err != nil { 20491 return err 20492 } 20493 if done { 20494 break 20495 } 20496 originalDecoder := decoder 20497 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20498 switch { 20499 case strings.EqualFold("TimezoneName", t.Name.Local): 20500 val, err := decoder.Value() 20501 if err != nil { 20502 return err 20503 } 20504 if val == nil { 20505 break 20506 } 20507 { 20508 xtv := string(val) 20509 sv.TimezoneName = ptr.String(xtv) 20510 } 20511 20512 default: 20513 // Do nothing and ignore the unexpected tag element 20514 err = decoder.Decoder.Skip() 20515 if err != nil { 20516 return err 20517 } 20518 20519 } 20520 decoder = originalDecoder 20521 } 20522 *v = sv 20523 return nil 20524} 20525 20526func awsAwsquery_deserializeDocumentUpgradeTarget(v **types.UpgradeTarget, decoder smithyxml.NodeDecoder) error { 20527 if v == nil { 20528 return fmt.Errorf("unexpected nil of type %T", v) 20529 } 20530 var sv *types.UpgradeTarget 20531 if *v == nil { 20532 sv = &types.UpgradeTarget{} 20533 } else { 20534 sv = *v 20535 } 20536 20537 for { 20538 t, done, err := decoder.Token() 20539 if err != nil { 20540 return err 20541 } 20542 if done { 20543 break 20544 } 20545 originalDecoder := decoder 20546 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20547 switch { 20548 case strings.EqualFold("AutoUpgrade", t.Name.Local): 20549 val, err := decoder.Value() 20550 if err != nil { 20551 return err 20552 } 20553 if val == nil { 20554 break 20555 } 20556 { 20557 xtv, err := strconv.ParseBool(string(val)) 20558 if err != nil { 20559 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 20560 } 20561 sv.AutoUpgrade = xtv 20562 } 20563 20564 case strings.EqualFold("Description", t.Name.Local): 20565 val, err := decoder.Value() 20566 if err != nil { 20567 return err 20568 } 20569 if val == nil { 20570 break 20571 } 20572 { 20573 xtv := string(val) 20574 sv.Description = ptr.String(xtv) 20575 } 20576 20577 case strings.EqualFold("Engine", t.Name.Local): 20578 val, err := decoder.Value() 20579 if err != nil { 20580 return err 20581 } 20582 if val == nil { 20583 break 20584 } 20585 { 20586 xtv := string(val) 20587 sv.Engine = ptr.String(xtv) 20588 } 20589 20590 case strings.EqualFold("EngineVersion", t.Name.Local): 20591 val, err := decoder.Value() 20592 if err != nil { 20593 return err 20594 } 20595 if val == nil { 20596 break 20597 } 20598 { 20599 xtv := string(val) 20600 sv.EngineVersion = ptr.String(xtv) 20601 } 20602 20603 case strings.EqualFold("IsMajorVersionUpgrade", t.Name.Local): 20604 val, err := decoder.Value() 20605 if err != nil { 20606 return err 20607 } 20608 if val == nil { 20609 break 20610 } 20611 { 20612 xtv, err := strconv.ParseBool(string(val)) 20613 if err != nil { 20614 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 20615 } 20616 sv.IsMajorVersionUpgrade = xtv 20617 } 20618 20619 default: 20620 // Do nothing and ignore the unexpected tag element 20621 err = decoder.Decoder.Skip() 20622 if err != nil { 20623 return err 20624 } 20625 20626 } 20627 decoder = originalDecoder 20628 } 20629 *v = sv 20630 return nil 20631} 20632 20633func awsAwsquery_deserializeDocumentValidDBInstanceModificationsMessage(v **types.ValidDBInstanceModificationsMessage, decoder smithyxml.NodeDecoder) error { 20634 if v == nil { 20635 return fmt.Errorf("unexpected nil of type %T", v) 20636 } 20637 var sv *types.ValidDBInstanceModificationsMessage 20638 if *v == nil { 20639 sv = &types.ValidDBInstanceModificationsMessage{} 20640 } else { 20641 sv = *v 20642 } 20643 20644 for { 20645 t, done, err := decoder.Token() 20646 if err != nil { 20647 return err 20648 } 20649 if done { 20650 break 20651 } 20652 originalDecoder := decoder 20653 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20654 switch { 20655 case strings.EqualFold("Storage", t.Name.Local): 20656 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20657 if err := awsAwsquery_deserializeDocumentValidStorageOptionsList(&sv.Storage, nodeDecoder); err != nil { 20658 return err 20659 } 20660 20661 default: 20662 // Do nothing and ignore the unexpected tag element 20663 err = decoder.Decoder.Skip() 20664 if err != nil { 20665 return err 20666 } 20667 20668 } 20669 decoder = originalDecoder 20670 } 20671 *v = sv 20672 return nil 20673} 20674 20675func awsAwsquery_deserializeDocumentValidStorageOptions(v **types.ValidStorageOptions, decoder smithyxml.NodeDecoder) error { 20676 if v == nil { 20677 return fmt.Errorf("unexpected nil of type %T", v) 20678 } 20679 var sv *types.ValidStorageOptions 20680 if *v == nil { 20681 sv = &types.ValidStorageOptions{} 20682 } else { 20683 sv = *v 20684 } 20685 20686 for { 20687 t, done, err := decoder.Token() 20688 if err != nil { 20689 return err 20690 } 20691 if done { 20692 break 20693 } 20694 originalDecoder := decoder 20695 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20696 switch { 20697 case strings.EqualFold("IopsToStorageRatio", t.Name.Local): 20698 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20699 if err := awsAwsquery_deserializeDocumentDoubleRangeList(&sv.IopsToStorageRatio, nodeDecoder); err != nil { 20700 return err 20701 } 20702 20703 case strings.EqualFold("ProvisionedIops", t.Name.Local): 20704 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20705 if err := awsAwsquery_deserializeDocumentRangeList(&sv.ProvisionedIops, nodeDecoder); err != nil { 20706 return err 20707 } 20708 20709 case strings.EqualFold("StorageSize", t.Name.Local): 20710 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20711 if err := awsAwsquery_deserializeDocumentRangeList(&sv.StorageSize, nodeDecoder); err != nil { 20712 return err 20713 } 20714 20715 case strings.EqualFold("StorageType", t.Name.Local): 20716 val, err := decoder.Value() 20717 if err != nil { 20718 return err 20719 } 20720 if val == nil { 20721 break 20722 } 20723 { 20724 xtv := string(val) 20725 sv.StorageType = ptr.String(xtv) 20726 } 20727 20728 default: 20729 // Do nothing and ignore the unexpected tag element 20730 err = decoder.Decoder.Skip() 20731 if err != nil { 20732 return err 20733 } 20734 20735 } 20736 decoder = originalDecoder 20737 } 20738 *v = sv 20739 return nil 20740} 20741 20742func awsAwsquery_deserializeDocumentValidStorageOptionsList(v *[]types.ValidStorageOptions, decoder smithyxml.NodeDecoder) error { 20743 if v == nil { 20744 return fmt.Errorf("unexpected nil of type %T", v) 20745 } 20746 var sv []types.ValidStorageOptions 20747 if *v == nil { 20748 sv = make([]types.ValidStorageOptions, 0) 20749 } else { 20750 sv = *v 20751 } 20752 20753 originalDecoder := decoder 20754 for { 20755 t, done, err := decoder.Token() 20756 if err != nil { 20757 return err 20758 } 20759 if done { 20760 break 20761 } 20762 switch { 20763 case strings.EqualFold("ValidStorageOptions", t.Name.Local): 20764 var col types.ValidStorageOptions 20765 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20766 destAddr := &col 20767 if err := awsAwsquery_deserializeDocumentValidStorageOptions(&destAddr, nodeDecoder); err != nil { 20768 return err 20769 } 20770 col = *destAddr 20771 sv = append(sv, col) 20772 20773 default: 20774 err = decoder.Decoder.Skip() 20775 if err != nil { 20776 return err 20777 } 20778 20779 } 20780 decoder = originalDecoder 20781 } 20782 *v = sv 20783 return nil 20784} 20785 20786func awsAwsquery_deserializeDocumentValidStorageOptionsListUnwrapped(v *[]types.ValidStorageOptions, decoder smithyxml.NodeDecoder) error { 20787 var sv []types.ValidStorageOptions 20788 if *v == nil { 20789 sv = make([]types.ValidStorageOptions, 0) 20790 } else { 20791 sv = *v 20792 } 20793 20794 switch { 20795 default: 20796 var mv types.ValidStorageOptions 20797 t := decoder.StartEl 20798 _ = t 20799 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20800 destAddr := &mv 20801 if err := awsAwsquery_deserializeDocumentValidStorageOptions(&destAddr, nodeDecoder); err != nil { 20802 return err 20803 } 20804 mv = *destAddr 20805 sv = append(sv, mv) 20806 } 20807 *v = sv 20808 return nil 20809} 20810func awsAwsquery_deserializeDocumentValidUpgradeTargetList(v *[]types.UpgradeTarget, decoder smithyxml.NodeDecoder) error { 20811 if v == nil { 20812 return fmt.Errorf("unexpected nil of type %T", v) 20813 } 20814 var sv []types.UpgradeTarget 20815 if *v == nil { 20816 sv = make([]types.UpgradeTarget, 0) 20817 } else { 20818 sv = *v 20819 } 20820 20821 originalDecoder := decoder 20822 for { 20823 t, done, err := decoder.Token() 20824 if err != nil { 20825 return err 20826 } 20827 if done { 20828 break 20829 } 20830 switch { 20831 case strings.EqualFold("UpgradeTarget", t.Name.Local): 20832 var col types.UpgradeTarget 20833 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20834 destAddr := &col 20835 if err := awsAwsquery_deserializeDocumentUpgradeTarget(&destAddr, nodeDecoder); err != nil { 20836 return err 20837 } 20838 col = *destAddr 20839 sv = append(sv, col) 20840 20841 default: 20842 err = decoder.Decoder.Skip() 20843 if err != nil { 20844 return err 20845 } 20846 20847 } 20848 decoder = originalDecoder 20849 } 20850 *v = sv 20851 return nil 20852} 20853 20854func awsAwsquery_deserializeDocumentValidUpgradeTargetListUnwrapped(v *[]types.UpgradeTarget, decoder smithyxml.NodeDecoder) error { 20855 var sv []types.UpgradeTarget 20856 if *v == nil { 20857 sv = make([]types.UpgradeTarget, 0) 20858 } else { 20859 sv = *v 20860 } 20861 20862 switch { 20863 default: 20864 var mv types.UpgradeTarget 20865 t := decoder.StartEl 20866 _ = t 20867 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20868 destAddr := &mv 20869 if err := awsAwsquery_deserializeDocumentUpgradeTarget(&destAddr, nodeDecoder); err != nil { 20870 return err 20871 } 20872 mv = *destAddr 20873 sv = append(sv, mv) 20874 } 20875 *v = sv 20876 return nil 20877} 20878func awsAwsquery_deserializeDocumentVpcSecurityGroupMembership(v **types.VpcSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 20879 if v == nil { 20880 return fmt.Errorf("unexpected nil of type %T", v) 20881 } 20882 var sv *types.VpcSecurityGroupMembership 20883 if *v == nil { 20884 sv = &types.VpcSecurityGroupMembership{} 20885 } else { 20886 sv = *v 20887 } 20888 20889 for { 20890 t, done, err := decoder.Token() 20891 if err != nil { 20892 return err 20893 } 20894 if done { 20895 break 20896 } 20897 originalDecoder := decoder 20898 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20899 switch { 20900 case strings.EqualFold("Status", t.Name.Local): 20901 val, err := decoder.Value() 20902 if err != nil { 20903 return err 20904 } 20905 if val == nil { 20906 break 20907 } 20908 { 20909 xtv := string(val) 20910 sv.Status = ptr.String(xtv) 20911 } 20912 20913 case strings.EqualFold("VpcSecurityGroupId", t.Name.Local): 20914 val, err := decoder.Value() 20915 if err != nil { 20916 return err 20917 } 20918 if val == nil { 20919 break 20920 } 20921 { 20922 xtv := string(val) 20923 sv.VpcSecurityGroupId = ptr.String(xtv) 20924 } 20925 20926 default: 20927 // Do nothing and ignore the unexpected tag element 20928 err = decoder.Decoder.Skip() 20929 if err != nil { 20930 return err 20931 } 20932 20933 } 20934 decoder = originalDecoder 20935 } 20936 *v = sv 20937 return nil 20938} 20939 20940func awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipList(v *[]types.VpcSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 20941 if v == nil { 20942 return fmt.Errorf("unexpected nil of type %T", v) 20943 } 20944 var sv []types.VpcSecurityGroupMembership 20945 if *v == nil { 20946 sv = make([]types.VpcSecurityGroupMembership, 0) 20947 } else { 20948 sv = *v 20949 } 20950 20951 originalDecoder := decoder 20952 for { 20953 t, done, err := decoder.Token() 20954 if err != nil { 20955 return err 20956 } 20957 if done { 20958 break 20959 } 20960 switch { 20961 case strings.EqualFold("VpcSecurityGroupMembership", t.Name.Local): 20962 var col types.VpcSecurityGroupMembership 20963 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20964 destAddr := &col 20965 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 20966 return err 20967 } 20968 col = *destAddr 20969 sv = append(sv, col) 20970 20971 default: 20972 err = decoder.Decoder.Skip() 20973 if err != nil { 20974 return err 20975 } 20976 20977 } 20978 decoder = originalDecoder 20979 } 20980 *v = sv 20981 return nil 20982} 20983 20984func awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipListUnwrapped(v *[]types.VpcSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 20985 var sv []types.VpcSecurityGroupMembership 20986 if *v == nil { 20987 sv = make([]types.VpcSecurityGroupMembership, 0) 20988 } else { 20989 sv = *v 20990 } 20991 20992 switch { 20993 default: 20994 var mv types.VpcSecurityGroupMembership 20995 t := decoder.StartEl 20996 _ = t 20997 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20998 destAddr := &mv 20999 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 21000 return err 21001 } 21002 mv = *destAddr 21003 sv = append(sv, mv) 21004 } 21005 *v = sv 21006 return nil 21007} 21008func awsAwsquery_deserializeOpDocumentAddSourceIdentifierToSubscriptionOutput(v **AddSourceIdentifierToSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 21009 if v == nil { 21010 return fmt.Errorf("unexpected nil of type %T", v) 21011 } 21012 var sv *AddSourceIdentifierToSubscriptionOutput 21013 if *v == nil { 21014 sv = &AddSourceIdentifierToSubscriptionOutput{} 21015 } else { 21016 sv = *v 21017 } 21018 21019 for { 21020 t, done, err := decoder.Token() 21021 if err != nil { 21022 return err 21023 } 21024 if done { 21025 break 21026 } 21027 originalDecoder := decoder 21028 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21029 switch { 21030 case strings.EqualFold("EventSubscription", t.Name.Local): 21031 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21032 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 21033 return err 21034 } 21035 21036 default: 21037 // Do nothing and ignore the unexpected tag element 21038 err = decoder.Decoder.Skip() 21039 if err != nil { 21040 return err 21041 } 21042 21043 } 21044 decoder = originalDecoder 21045 } 21046 *v = sv 21047 return nil 21048} 21049 21050func awsAwsquery_deserializeOpDocumentApplyPendingMaintenanceActionOutput(v **ApplyPendingMaintenanceActionOutput, decoder smithyxml.NodeDecoder) error { 21051 if v == nil { 21052 return fmt.Errorf("unexpected nil of type %T", v) 21053 } 21054 var sv *ApplyPendingMaintenanceActionOutput 21055 if *v == nil { 21056 sv = &ApplyPendingMaintenanceActionOutput{} 21057 } else { 21058 sv = *v 21059 } 21060 21061 for { 21062 t, done, err := decoder.Token() 21063 if err != nil { 21064 return err 21065 } 21066 if done { 21067 break 21068 } 21069 originalDecoder := decoder 21070 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21071 switch { 21072 case strings.EqualFold("ResourcePendingMaintenanceActions", t.Name.Local): 21073 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21074 if err := awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(&sv.ResourcePendingMaintenanceActions, nodeDecoder); err != nil { 21075 return err 21076 } 21077 21078 default: 21079 // Do nothing and ignore the unexpected tag element 21080 err = decoder.Decoder.Skip() 21081 if err != nil { 21082 return err 21083 } 21084 21085 } 21086 decoder = originalDecoder 21087 } 21088 *v = sv 21089 return nil 21090} 21091 21092func awsAwsquery_deserializeOpDocumentCopyDBClusterParameterGroupOutput(v **CopyDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21093 if v == nil { 21094 return fmt.Errorf("unexpected nil of type %T", v) 21095 } 21096 var sv *CopyDBClusterParameterGroupOutput 21097 if *v == nil { 21098 sv = &CopyDBClusterParameterGroupOutput{} 21099 } else { 21100 sv = *v 21101 } 21102 21103 for { 21104 t, done, err := decoder.Token() 21105 if err != nil { 21106 return err 21107 } 21108 if done { 21109 break 21110 } 21111 originalDecoder := decoder 21112 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21113 switch { 21114 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 21115 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21116 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&sv.DBClusterParameterGroup, nodeDecoder); err != nil { 21117 return err 21118 } 21119 21120 default: 21121 // Do nothing and ignore the unexpected tag element 21122 err = decoder.Decoder.Skip() 21123 if err != nil { 21124 return err 21125 } 21126 21127 } 21128 decoder = originalDecoder 21129 } 21130 *v = sv 21131 return nil 21132} 21133 21134func awsAwsquery_deserializeOpDocumentCopyDBClusterSnapshotOutput(v **CopyDBClusterSnapshotOutput, decoder smithyxml.NodeDecoder) error { 21135 if v == nil { 21136 return fmt.Errorf("unexpected nil of type %T", v) 21137 } 21138 var sv *CopyDBClusterSnapshotOutput 21139 if *v == nil { 21140 sv = &CopyDBClusterSnapshotOutput{} 21141 } else { 21142 sv = *v 21143 } 21144 21145 for { 21146 t, done, err := decoder.Token() 21147 if err != nil { 21148 return err 21149 } 21150 if done { 21151 break 21152 } 21153 originalDecoder := decoder 21154 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21155 switch { 21156 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 21157 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21158 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&sv.DBClusterSnapshot, nodeDecoder); err != nil { 21159 return err 21160 } 21161 21162 default: 21163 // Do nothing and ignore the unexpected tag element 21164 err = decoder.Decoder.Skip() 21165 if err != nil { 21166 return err 21167 } 21168 21169 } 21170 decoder = originalDecoder 21171 } 21172 *v = sv 21173 return nil 21174} 21175 21176func awsAwsquery_deserializeOpDocumentCopyDBParameterGroupOutput(v **CopyDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21177 if v == nil { 21178 return fmt.Errorf("unexpected nil of type %T", v) 21179 } 21180 var sv *CopyDBParameterGroupOutput 21181 if *v == nil { 21182 sv = &CopyDBParameterGroupOutput{} 21183 } else { 21184 sv = *v 21185 } 21186 21187 for { 21188 t, done, err := decoder.Token() 21189 if err != nil { 21190 return err 21191 } 21192 if done { 21193 break 21194 } 21195 originalDecoder := decoder 21196 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21197 switch { 21198 case strings.EqualFold("DBParameterGroup", t.Name.Local): 21199 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21200 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&sv.DBParameterGroup, nodeDecoder); err != nil { 21201 return err 21202 } 21203 21204 default: 21205 // Do nothing and ignore the unexpected tag element 21206 err = decoder.Decoder.Skip() 21207 if err != nil { 21208 return err 21209 } 21210 21211 } 21212 decoder = originalDecoder 21213 } 21214 *v = sv 21215 return nil 21216} 21217 21218func awsAwsquery_deserializeOpDocumentCreateDBClusterEndpointOutput(v **CreateDBClusterEndpointOutput, decoder smithyxml.NodeDecoder) error { 21219 if v == nil { 21220 return fmt.Errorf("unexpected nil of type %T", v) 21221 } 21222 var sv *CreateDBClusterEndpointOutput 21223 if *v == nil { 21224 sv = &CreateDBClusterEndpointOutput{} 21225 } else { 21226 sv = *v 21227 } 21228 21229 for { 21230 t, done, err := decoder.Token() 21231 if err != nil { 21232 return err 21233 } 21234 if done { 21235 break 21236 } 21237 originalDecoder := decoder 21238 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21239 switch { 21240 case strings.EqualFold("CustomEndpointType", t.Name.Local): 21241 val, err := decoder.Value() 21242 if err != nil { 21243 return err 21244 } 21245 if val == nil { 21246 break 21247 } 21248 { 21249 xtv := string(val) 21250 sv.CustomEndpointType = ptr.String(xtv) 21251 } 21252 21253 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 21254 val, err := decoder.Value() 21255 if err != nil { 21256 return err 21257 } 21258 if val == nil { 21259 break 21260 } 21261 { 21262 xtv := string(val) 21263 sv.DBClusterEndpointArn = ptr.String(xtv) 21264 } 21265 21266 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 21267 val, err := decoder.Value() 21268 if err != nil { 21269 return err 21270 } 21271 if val == nil { 21272 break 21273 } 21274 { 21275 xtv := string(val) 21276 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 21277 } 21278 21279 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 21280 val, err := decoder.Value() 21281 if err != nil { 21282 return err 21283 } 21284 if val == nil { 21285 break 21286 } 21287 { 21288 xtv := string(val) 21289 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 21290 } 21291 21292 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 21293 val, err := decoder.Value() 21294 if err != nil { 21295 return err 21296 } 21297 if val == nil { 21298 break 21299 } 21300 { 21301 xtv := string(val) 21302 sv.DBClusterIdentifier = ptr.String(xtv) 21303 } 21304 21305 case strings.EqualFold("Endpoint", t.Name.Local): 21306 val, err := decoder.Value() 21307 if err != nil { 21308 return err 21309 } 21310 if val == nil { 21311 break 21312 } 21313 { 21314 xtv := string(val) 21315 sv.Endpoint = ptr.String(xtv) 21316 } 21317 21318 case strings.EqualFold("EndpointType", t.Name.Local): 21319 val, err := decoder.Value() 21320 if err != nil { 21321 return err 21322 } 21323 if val == nil { 21324 break 21325 } 21326 { 21327 xtv := string(val) 21328 sv.EndpointType = ptr.String(xtv) 21329 } 21330 21331 case strings.EqualFold("ExcludedMembers", t.Name.Local): 21332 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21333 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 21334 return err 21335 } 21336 21337 case strings.EqualFold("StaticMembers", t.Name.Local): 21338 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21339 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 21340 return err 21341 } 21342 21343 case strings.EqualFold("Status", t.Name.Local): 21344 val, err := decoder.Value() 21345 if err != nil { 21346 return err 21347 } 21348 if val == nil { 21349 break 21350 } 21351 { 21352 xtv := string(val) 21353 sv.Status = ptr.String(xtv) 21354 } 21355 21356 default: 21357 // Do nothing and ignore the unexpected tag element 21358 err = decoder.Decoder.Skip() 21359 if err != nil { 21360 return err 21361 } 21362 21363 } 21364 decoder = originalDecoder 21365 } 21366 *v = sv 21367 return nil 21368} 21369 21370func awsAwsquery_deserializeOpDocumentCreateDBClusterOutput(v **CreateDBClusterOutput, decoder smithyxml.NodeDecoder) error { 21371 if v == nil { 21372 return fmt.Errorf("unexpected nil of type %T", v) 21373 } 21374 var sv *CreateDBClusterOutput 21375 if *v == nil { 21376 sv = &CreateDBClusterOutput{} 21377 } else { 21378 sv = *v 21379 } 21380 21381 for { 21382 t, done, err := decoder.Token() 21383 if err != nil { 21384 return err 21385 } 21386 if done { 21387 break 21388 } 21389 originalDecoder := decoder 21390 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21391 switch { 21392 case strings.EqualFold("DBCluster", t.Name.Local): 21393 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21394 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 21395 return err 21396 } 21397 21398 default: 21399 // Do nothing and ignore the unexpected tag element 21400 err = decoder.Decoder.Skip() 21401 if err != nil { 21402 return err 21403 } 21404 21405 } 21406 decoder = originalDecoder 21407 } 21408 *v = sv 21409 return nil 21410} 21411 21412func awsAwsquery_deserializeOpDocumentCreateDBClusterParameterGroupOutput(v **CreateDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21413 if v == nil { 21414 return fmt.Errorf("unexpected nil of type %T", v) 21415 } 21416 var sv *CreateDBClusterParameterGroupOutput 21417 if *v == nil { 21418 sv = &CreateDBClusterParameterGroupOutput{} 21419 } else { 21420 sv = *v 21421 } 21422 21423 for { 21424 t, done, err := decoder.Token() 21425 if err != nil { 21426 return err 21427 } 21428 if done { 21429 break 21430 } 21431 originalDecoder := decoder 21432 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21433 switch { 21434 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 21435 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21436 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&sv.DBClusterParameterGroup, nodeDecoder); err != nil { 21437 return err 21438 } 21439 21440 default: 21441 // Do nothing and ignore the unexpected tag element 21442 err = decoder.Decoder.Skip() 21443 if err != nil { 21444 return err 21445 } 21446 21447 } 21448 decoder = originalDecoder 21449 } 21450 *v = sv 21451 return nil 21452} 21453 21454func awsAwsquery_deserializeOpDocumentCreateDBClusterSnapshotOutput(v **CreateDBClusterSnapshotOutput, decoder smithyxml.NodeDecoder) error { 21455 if v == nil { 21456 return fmt.Errorf("unexpected nil of type %T", v) 21457 } 21458 var sv *CreateDBClusterSnapshotOutput 21459 if *v == nil { 21460 sv = &CreateDBClusterSnapshotOutput{} 21461 } else { 21462 sv = *v 21463 } 21464 21465 for { 21466 t, done, err := decoder.Token() 21467 if err != nil { 21468 return err 21469 } 21470 if done { 21471 break 21472 } 21473 originalDecoder := decoder 21474 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21475 switch { 21476 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 21477 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21478 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&sv.DBClusterSnapshot, nodeDecoder); err != nil { 21479 return err 21480 } 21481 21482 default: 21483 // Do nothing and ignore the unexpected tag element 21484 err = decoder.Decoder.Skip() 21485 if err != nil { 21486 return err 21487 } 21488 21489 } 21490 decoder = originalDecoder 21491 } 21492 *v = sv 21493 return nil 21494} 21495 21496func awsAwsquery_deserializeOpDocumentCreateDBInstanceOutput(v **CreateDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 21497 if v == nil { 21498 return fmt.Errorf("unexpected nil of type %T", v) 21499 } 21500 var sv *CreateDBInstanceOutput 21501 if *v == nil { 21502 sv = &CreateDBInstanceOutput{} 21503 } else { 21504 sv = *v 21505 } 21506 21507 for { 21508 t, done, err := decoder.Token() 21509 if err != nil { 21510 return err 21511 } 21512 if done { 21513 break 21514 } 21515 originalDecoder := decoder 21516 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21517 switch { 21518 case strings.EqualFold("DBInstance", t.Name.Local): 21519 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21520 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 21521 return err 21522 } 21523 21524 default: 21525 // Do nothing and ignore the unexpected tag element 21526 err = decoder.Decoder.Skip() 21527 if err != nil { 21528 return err 21529 } 21530 21531 } 21532 decoder = originalDecoder 21533 } 21534 *v = sv 21535 return nil 21536} 21537 21538func awsAwsquery_deserializeOpDocumentCreateDBParameterGroupOutput(v **CreateDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21539 if v == nil { 21540 return fmt.Errorf("unexpected nil of type %T", v) 21541 } 21542 var sv *CreateDBParameterGroupOutput 21543 if *v == nil { 21544 sv = &CreateDBParameterGroupOutput{} 21545 } else { 21546 sv = *v 21547 } 21548 21549 for { 21550 t, done, err := decoder.Token() 21551 if err != nil { 21552 return err 21553 } 21554 if done { 21555 break 21556 } 21557 originalDecoder := decoder 21558 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21559 switch { 21560 case strings.EqualFold("DBParameterGroup", t.Name.Local): 21561 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21562 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&sv.DBParameterGroup, nodeDecoder); err != nil { 21563 return err 21564 } 21565 21566 default: 21567 // Do nothing and ignore the unexpected tag element 21568 err = decoder.Decoder.Skip() 21569 if err != nil { 21570 return err 21571 } 21572 21573 } 21574 decoder = originalDecoder 21575 } 21576 *v = sv 21577 return nil 21578} 21579 21580func awsAwsquery_deserializeOpDocumentCreateDBSubnetGroupOutput(v **CreateDBSubnetGroupOutput, decoder smithyxml.NodeDecoder) error { 21581 if v == nil { 21582 return fmt.Errorf("unexpected nil of type %T", v) 21583 } 21584 var sv *CreateDBSubnetGroupOutput 21585 if *v == nil { 21586 sv = &CreateDBSubnetGroupOutput{} 21587 } else { 21588 sv = *v 21589 } 21590 21591 for { 21592 t, done, err := decoder.Token() 21593 if err != nil { 21594 return err 21595 } 21596 if done { 21597 break 21598 } 21599 originalDecoder := decoder 21600 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21601 switch { 21602 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 21603 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21604 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&sv.DBSubnetGroup, nodeDecoder); err != nil { 21605 return err 21606 } 21607 21608 default: 21609 // Do nothing and ignore the unexpected tag element 21610 err = decoder.Decoder.Skip() 21611 if err != nil { 21612 return err 21613 } 21614 21615 } 21616 decoder = originalDecoder 21617 } 21618 *v = sv 21619 return nil 21620} 21621 21622func awsAwsquery_deserializeOpDocumentCreateEventSubscriptionOutput(v **CreateEventSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 21623 if v == nil { 21624 return fmt.Errorf("unexpected nil of type %T", v) 21625 } 21626 var sv *CreateEventSubscriptionOutput 21627 if *v == nil { 21628 sv = &CreateEventSubscriptionOutput{} 21629 } else { 21630 sv = *v 21631 } 21632 21633 for { 21634 t, done, err := decoder.Token() 21635 if err != nil { 21636 return err 21637 } 21638 if done { 21639 break 21640 } 21641 originalDecoder := decoder 21642 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21643 switch { 21644 case strings.EqualFold("EventSubscription", t.Name.Local): 21645 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21646 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 21647 return err 21648 } 21649 21650 default: 21651 // Do nothing and ignore the unexpected tag element 21652 err = decoder.Decoder.Skip() 21653 if err != nil { 21654 return err 21655 } 21656 21657 } 21658 decoder = originalDecoder 21659 } 21660 *v = sv 21661 return nil 21662} 21663 21664func awsAwsquery_deserializeOpDocumentDeleteDBClusterEndpointOutput(v **DeleteDBClusterEndpointOutput, decoder smithyxml.NodeDecoder) error { 21665 if v == nil { 21666 return fmt.Errorf("unexpected nil of type %T", v) 21667 } 21668 var sv *DeleteDBClusterEndpointOutput 21669 if *v == nil { 21670 sv = &DeleteDBClusterEndpointOutput{} 21671 } else { 21672 sv = *v 21673 } 21674 21675 for { 21676 t, done, err := decoder.Token() 21677 if err != nil { 21678 return err 21679 } 21680 if done { 21681 break 21682 } 21683 originalDecoder := decoder 21684 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21685 switch { 21686 case strings.EqualFold("CustomEndpointType", t.Name.Local): 21687 val, err := decoder.Value() 21688 if err != nil { 21689 return err 21690 } 21691 if val == nil { 21692 break 21693 } 21694 { 21695 xtv := string(val) 21696 sv.CustomEndpointType = ptr.String(xtv) 21697 } 21698 21699 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 21700 val, err := decoder.Value() 21701 if err != nil { 21702 return err 21703 } 21704 if val == nil { 21705 break 21706 } 21707 { 21708 xtv := string(val) 21709 sv.DBClusterEndpointArn = ptr.String(xtv) 21710 } 21711 21712 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 21713 val, err := decoder.Value() 21714 if err != nil { 21715 return err 21716 } 21717 if val == nil { 21718 break 21719 } 21720 { 21721 xtv := string(val) 21722 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 21723 } 21724 21725 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 21726 val, err := decoder.Value() 21727 if err != nil { 21728 return err 21729 } 21730 if val == nil { 21731 break 21732 } 21733 { 21734 xtv := string(val) 21735 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 21736 } 21737 21738 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 21739 val, err := decoder.Value() 21740 if err != nil { 21741 return err 21742 } 21743 if val == nil { 21744 break 21745 } 21746 { 21747 xtv := string(val) 21748 sv.DBClusterIdentifier = ptr.String(xtv) 21749 } 21750 21751 case strings.EqualFold("Endpoint", t.Name.Local): 21752 val, err := decoder.Value() 21753 if err != nil { 21754 return err 21755 } 21756 if val == nil { 21757 break 21758 } 21759 { 21760 xtv := string(val) 21761 sv.Endpoint = ptr.String(xtv) 21762 } 21763 21764 case strings.EqualFold("EndpointType", t.Name.Local): 21765 val, err := decoder.Value() 21766 if err != nil { 21767 return err 21768 } 21769 if val == nil { 21770 break 21771 } 21772 { 21773 xtv := string(val) 21774 sv.EndpointType = ptr.String(xtv) 21775 } 21776 21777 case strings.EqualFold("ExcludedMembers", t.Name.Local): 21778 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21779 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 21780 return err 21781 } 21782 21783 case strings.EqualFold("StaticMembers", t.Name.Local): 21784 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21785 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 21786 return err 21787 } 21788 21789 case strings.EqualFold("Status", t.Name.Local): 21790 val, err := decoder.Value() 21791 if err != nil { 21792 return err 21793 } 21794 if val == nil { 21795 break 21796 } 21797 { 21798 xtv := string(val) 21799 sv.Status = ptr.String(xtv) 21800 } 21801 21802 default: 21803 // Do nothing and ignore the unexpected tag element 21804 err = decoder.Decoder.Skip() 21805 if err != nil { 21806 return err 21807 } 21808 21809 } 21810 decoder = originalDecoder 21811 } 21812 *v = sv 21813 return nil 21814} 21815 21816func awsAwsquery_deserializeOpDocumentDeleteDBClusterOutput(v **DeleteDBClusterOutput, decoder smithyxml.NodeDecoder) error { 21817 if v == nil { 21818 return fmt.Errorf("unexpected nil of type %T", v) 21819 } 21820 var sv *DeleteDBClusterOutput 21821 if *v == nil { 21822 sv = &DeleteDBClusterOutput{} 21823 } else { 21824 sv = *v 21825 } 21826 21827 for { 21828 t, done, err := decoder.Token() 21829 if err != nil { 21830 return err 21831 } 21832 if done { 21833 break 21834 } 21835 originalDecoder := decoder 21836 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21837 switch { 21838 case strings.EqualFold("DBCluster", t.Name.Local): 21839 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21840 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 21841 return err 21842 } 21843 21844 default: 21845 // Do nothing and ignore the unexpected tag element 21846 err = decoder.Decoder.Skip() 21847 if err != nil { 21848 return err 21849 } 21850 21851 } 21852 decoder = originalDecoder 21853 } 21854 *v = sv 21855 return nil 21856} 21857 21858func awsAwsquery_deserializeOpDocumentDeleteDBClusterSnapshotOutput(v **DeleteDBClusterSnapshotOutput, decoder smithyxml.NodeDecoder) error { 21859 if v == nil { 21860 return fmt.Errorf("unexpected nil of type %T", v) 21861 } 21862 var sv *DeleteDBClusterSnapshotOutput 21863 if *v == nil { 21864 sv = &DeleteDBClusterSnapshotOutput{} 21865 } else { 21866 sv = *v 21867 } 21868 21869 for { 21870 t, done, err := decoder.Token() 21871 if err != nil { 21872 return err 21873 } 21874 if done { 21875 break 21876 } 21877 originalDecoder := decoder 21878 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21879 switch { 21880 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 21881 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21882 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&sv.DBClusterSnapshot, nodeDecoder); err != nil { 21883 return err 21884 } 21885 21886 default: 21887 // Do nothing and ignore the unexpected tag element 21888 err = decoder.Decoder.Skip() 21889 if err != nil { 21890 return err 21891 } 21892 21893 } 21894 decoder = originalDecoder 21895 } 21896 *v = sv 21897 return nil 21898} 21899 21900func awsAwsquery_deserializeOpDocumentDeleteDBInstanceOutput(v **DeleteDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 21901 if v == nil { 21902 return fmt.Errorf("unexpected nil of type %T", v) 21903 } 21904 var sv *DeleteDBInstanceOutput 21905 if *v == nil { 21906 sv = &DeleteDBInstanceOutput{} 21907 } else { 21908 sv = *v 21909 } 21910 21911 for { 21912 t, done, err := decoder.Token() 21913 if err != nil { 21914 return err 21915 } 21916 if done { 21917 break 21918 } 21919 originalDecoder := decoder 21920 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21921 switch { 21922 case strings.EqualFold("DBInstance", t.Name.Local): 21923 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21924 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 21925 return err 21926 } 21927 21928 default: 21929 // Do nothing and ignore the unexpected tag element 21930 err = decoder.Decoder.Skip() 21931 if err != nil { 21932 return err 21933 } 21934 21935 } 21936 decoder = originalDecoder 21937 } 21938 *v = sv 21939 return nil 21940} 21941 21942func awsAwsquery_deserializeOpDocumentDeleteEventSubscriptionOutput(v **DeleteEventSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 21943 if v == nil { 21944 return fmt.Errorf("unexpected nil of type %T", v) 21945 } 21946 var sv *DeleteEventSubscriptionOutput 21947 if *v == nil { 21948 sv = &DeleteEventSubscriptionOutput{} 21949 } else { 21950 sv = *v 21951 } 21952 21953 for { 21954 t, done, err := decoder.Token() 21955 if err != nil { 21956 return err 21957 } 21958 if done { 21959 break 21960 } 21961 originalDecoder := decoder 21962 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21963 switch { 21964 case strings.EqualFold("EventSubscription", t.Name.Local): 21965 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21966 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 21967 return err 21968 } 21969 21970 default: 21971 // Do nothing and ignore the unexpected tag element 21972 err = decoder.Decoder.Skip() 21973 if err != nil { 21974 return err 21975 } 21976 21977 } 21978 decoder = originalDecoder 21979 } 21980 *v = sv 21981 return nil 21982} 21983 21984func awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(v **DescribeDBClusterEndpointsOutput, decoder smithyxml.NodeDecoder) error { 21985 if v == nil { 21986 return fmt.Errorf("unexpected nil of type %T", v) 21987 } 21988 var sv *DescribeDBClusterEndpointsOutput 21989 if *v == nil { 21990 sv = &DescribeDBClusterEndpointsOutput{} 21991 } else { 21992 sv = *v 21993 } 21994 21995 for { 21996 t, done, err := decoder.Token() 21997 if err != nil { 21998 return err 21999 } 22000 if done { 22001 break 22002 } 22003 originalDecoder := decoder 22004 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22005 switch { 22006 case strings.EqualFold("DBClusterEndpoints", t.Name.Local): 22007 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22008 if err := awsAwsquery_deserializeDocumentDBClusterEndpointList(&sv.DBClusterEndpoints, nodeDecoder); err != nil { 22009 return err 22010 } 22011 22012 case strings.EqualFold("Marker", t.Name.Local): 22013 val, err := decoder.Value() 22014 if err != nil { 22015 return err 22016 } 22017 if val == nil { 22018 break 22019 } 22020 { 22021 xtv := string(val) 22022 sv.Marker = ptr.String(xtv) 22023 } 22024 22025 default: 22026 // Do nothing and ignore the unexpected tag element 22027 err = decoder.Decoder.Skip() 22028 if err != nil { 22029 return err 22030 } 22031 22032 } 22033 decoder = originalDecoder 22034 } 22035 *v = sv 22036 return nil 22037} 22038 22039func awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(v **DescribeDBClusterParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { 22040 if v == nil { 22041 return fmt.Errorf("unexpected nil of type %T", v) 22042 } 22043 var sv *DescribeDBClusterParameterGroupsOutput 22044 if *v == nil { 22045 sv = &DescribeDBClusterParameterGroupsOutput{} 22046 } else { 22047 sv = *v 22048 } 22049 22050 for { 22051 t, done, err := decoder.Token() 22052 if err != nil { 22053 return err 22054 } 22055 if done { 22056 break 22057 } 22058 originalDecoder := decoder 22059 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22060 switch { 22061 case strings.EqualFold("DBClusterParameterGroups", t.Name.Local): 22062 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22063 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroupList(&sv.DBClusterParameterGroups, nodeDecoder); err != nil { 22064 return err 22065 } 22066 22067 case strings.EqualFold("Marker", t.Name.Local): 22068 val, err := decoder.Value() 22069 if err != nil { 22070 return err 22071 } 22072 if val == nil { 22073 break 22074 } 22075 { 22076 xtv := string(val) 22077 sv.Marker = ptr.String(xtv) 22078 } 22079 22080 default: 22081 // Do nothing and ignore the unexpected tag element 22082 err = decoder.Decoder.Skip() 22083 if err != nil { 22084 return err 22085 } 22086 22087 } 22088 decoder = originalDecoder 22089 } 22090 *v = sv 22091 return nil 22092} 22093 22094func awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(v **DescribeDBClusterParametersOutput, decoder smithyxml.NodeDecoder) error { 22095 if v == nil { 22096 return fmt.Errorf("unexpected nil of type %T", v) 22097 } 22098 var sv *DescribeDBClusterParametersOutput 22099 if *v == nil { 22100 sv = &DescribeDBClusterParametersOutput{} 22101 } else { 22102 sv = *v 22103 } 22104 22105 for { 22106 t, done, err := decoder.Token() 22107 if err != nil { 22108 return err 22109 } 22110 if done { 22111 break 22112 } 22113 originalDecoder := decoder 22114 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22115 switch { 22116 case strings.EqualFold("Marker", t.Name.Local): 22117 val, err := decoder.Value() 22118 if err != nil { 22119 return err 22120 } 22121 if val == nil { 22122 break 22123 } 22124 { 22125 xtv := string(val) 22126 sv.Marker = ptr.String(xtv) 22127 } 22128 22129 case strings.EqualFold("Parameters", t.Name.Local): 22130 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22131 if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { 22132 return err 22133 } 22134 22135 default: 22136 // Do nothing and ignore the unexpected tag element 22137 err = decoder.Decoder.Skip() 22138 if err != nil { 22139 return err 22140 } 22141 22142 } 22143 decoder = originalDecoder 22144 } 22145 *v = sv 22146 return nil 22147} 22148 22149func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput(v **DescribeDBClusterSnapshotAttributesOutput, decoder smithyxml.NodeDecoder) error { 22150 if v == nil { 22151 return fmt.Errorf("unexpected nil of type %T", v) 22152 } 22153 var sv *DescribeDBClusterSnapshotAttributesOutput 22154 if *v == nil { 22155 sv = &DescribeDBClusterSnapshotAttributesOutput{} 22156 } else { 22157 sv = *v 22158 } 22159 22160 for { 22161 t, done, err := decoder.Token() 22162 if err != nil { 22163 return err 22164 } 22165 if done { 22166 break 22167 } 22168 originalDecoder := decoder 22169 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22170 switch { 22171 case strings.EqualFold("DBClusterSnapshotAttributesResult", t.Name.Local): 22172 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22173 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(&sv.DBClusterSnapshotAttributesResult, nodeDecoder); err != nil { 22174 return err 22175 } 22176 22177 default: 22178 // Do nothing and ignore the unexpected tag element 22179 err = decoder.Decoder.Skip() 22180 if err != nil { 22181 return err 22182 } 22183 22184 } 22185 decoder = originalDecoder 22186 } 22187 *v = sv 22188 return nil 22189} 22190 22191func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(v **DescribeDBClusterSnapshotsOutput, decoder smithyxml.NodeDecoder) error { 22192 if v == nil { 22193 return fmt.Errorf("unexpected nil of type %T", v) 22194 } 22195 var sv *DescribeDBClusterSnapshotsOutput 22196 if *v == nil { 22197 sv = &DescribeDBClusterSnapshotsOutput{} 22198 } else { 22199 sv = *v 22200 } 22201 22202 for { 22203 t, done, err := decoder.Token() 22204 if err != nil { 22205 return err 22206 } 22207 if done { 22208 break 22209 } 22210 originalDecoder := decoder 22211 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22212 switch { 22213 case strings.EqualFold("DBClusterSnapshots", t.Name.Local): 22214 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22215 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotList(&sv.DBClusterSnapshots, nodeDecoder); err != nil { 22216 return err 22217 } 22218 22219 case strings.EqualFold("Marker", t.Name.Local): 22220 val, err := decoder.Value() 22221 if err != nil { 22222 return err 22223 } 22224 if val == nil { 22225 break 22226 } 22227 { 22228 xtv := string(val) 22229 sv.Marker = ptr.String(xtv) 22230 } 22231 22232 default: 22233 // Do nothing and ignore the unexpected tag element 22234 err = decoder.Decoder.Skip() 22235 if err != nil { 22236 return err 22237 } 22238 22239 } 22240 decoder = originalDecoder 22241 } 22242 *v = sv 22243 return nil 22244} 22245 22246func awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(v **DescribeDBClustersOutput, decoder smithyxml.NodeDecoder) error { 22247 if v == nil { 22248 return fmt.Errorf("unexpected nil of type %T", v) 22249 } 22250 var sv *DescribeDBClustersOutput 22251 if *v == nil { 22252 sv = &DescribeDBClustersOutput{} 22253 } else { 22254 sv = *v 22255 } 22256 22257 for { 22258 t, done, err := decoder.Token() 22259 if err != nil { 22260 return err 22261 } 22262 if done { 22263 break 22264 } 22265 originalDecoder := decoder 22266 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22267 switch { 22268 case strings.EqualFold("DBClusters", t.Name.Local): 22269 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22270 if err := awsAwsquery_deserializeDocumentDBClusterList(&sv.DBClusters, nodeDecoder); err != nil { 22271 return err 22272 } 22273 22274 case strings.EqualFold("Marker", t.Name.Local): 22275 val, err := decoder.Value() 22276 if err != nil { 22277 return err 22278 } 22279 if val == nil { 22280 break 22281 } 22282 { 22283 xtv := string(val) 22284 sv.Marker = ptr.String(xtv) 22285 } 22286 22287 default: 22288 // Do nothing and ignore the unexpected tag element 22289 err = decoder.Decoder.Skip() 22290 if err != nil { 22291 return err 22292 } 22293 22294 } 22295 decoder = originalDecoder 22296 } 22297 *v = sv 22298 return nil 22299} 22300 22301func awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(v **DescribeDBEngineVersionsOutput, decoder smithyxml.NodeDecoder) error { 22302 if v == nil { 22303 return fmt.Errorf("unexpected nil of type %T", v) 22304 } 22305 var sv *DescribeDBEngineVersionsOutput 22306 if *v == nil { 22307 sv = &DescribeDBEngineVersionsOutput{} 22308 } else { 22309 sv = *v 22310 } 22311 22312 for { 22313 t, done, err := decoder.Token() 22314 if err != nil { 22315 return err 22316 } 22317 if done { 22318 break 22319 } 22320 originalDecoder := decoder 22321 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22322 switch { 22323 case strings.EqualFold("DBEngineVersions", t.Name.Local): 22324 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22325 if err := awsAwsquery_deserializeDocumentDBEngineVersionList(&sv.DBEngineVersions, nodeDecoder); err != nil { 22326 return err 22327 } 22328 22329 case strings.EqualFold("Marker", t.Name.Local): 22330 val, err := decoder.Value() 22331 if err != nil { 22332 return err 22333 } 22334 if val == nil { 22335 break 22336 } 22337 { 22338 xtv := string(val) 22339 sv.Marker = ptr.String(xtv) 22340 } 22341 22342 default: 22343 // Do nothing and ignore the unexpected tag element 22344 err = decoder.Decoder.Skip() 22345 if err != nil { 22346 return err 22347 } 22348 22349 } 22350 decoder = originalDecoder 22351 } 22352 *v = sv 22353 return nil 22354} 22355 22356func awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(v **DescribeDBInstancesOutput, decoder smithyxml.NodeDecoder) error { 22357 if v == nil { 22358 return fmt.Errorf("unexpected nil of type %T", v) 22359 } 22360 var sv *DescribeDBInstancesOutput 22361 if *v == nil { 22362 sv = &DescribeDBInstancesOutput{} 22363 } else { 22364 sv = *v 22365 } 22366 22367 for { 22368 t, done, err := decoder.Token() 22369 if err != nil { 22370 return err 22371 } 22372 if done { 22373 break 22374 } 22375 originalDecoder := decoder 22376 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22377 switch { 22378 case strings.EqualFold("DBInstances", t.Name.Local): 22379 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22380 if err := awsAwsquery_deserializeDocumentDBInstanceList(&sv.DBInstances, nodeDecoder); err != nil { 22381 return err 22382 } 22383 22384 case strings.EqualFold("Marker", t.Name.Local): 22385 val, err := decoder.Value() 22386 if err != nil { 22387 return err 22388 } 22389 if val == nil { 22390 break 22391 } 22392 { 22393 xtv := string(val) 22394 sv.Marker = ptr.String(xtv) 22395 } 22396 22397 default: 22398 // Do nothing and ignore the unexpected tag element 22399 err = decoder.Decoder.Skip() 22400 if err != nil { 22401 return err 22402 } 22403 22404 } 22405 decoder = originalDecoder 22406 } 22407 *v = sv 22408 return nil 22409} 22410 22411func awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(v **DescribeDBParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { 22412 if v == nil { 22413 return fmt.Errorf("unexpected nil of type %T", v) 22414 } 22415 var sv *DescribeDBParameterGroupsOutput 22416 if *v == nil { 22417 sv = &DescribeDBParameterGroupsOutput{} 22418 } else { 22419 sv = *v 22420 } 22421 22422 for { 22423 t, done, err := decoder.Token() 22424 if err != nil { 22425 return err 22426 } 22427 if done { 22428 break 22429 } 22430 originalDecoder := decoder 22431 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22432 switch { 22433 case strings.EqualFold("DBParameterGroups", t.Name.Local): 22434 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22435 if err := awsAwsquery_deserializeDocumentDBParameterGroupList(&sv.DBParameterGroups, nodeDecoder); err != nil { 22436 return err 22437 } 22438 22439 case strings.EqualFold("Marker", t.Name.Local): 22440 val, err := decoder.Value() 22441 if err != nil { 22442 return err 22443 } 22444 if val == nil { 22445 break 22446 } 22447 { 22448 xtv := string(val) 22449 sv.Marker = ptr.String(xtv) 22450 } 22451 22452 default: 22453 // Do nothing and ignore the unexpected tag element 22454 err = decoder.Decoder.Skip() 22455 if err != nil { 22456 return err 22457 } 22458 22459 } 22460 decoder = originalDecoder 22461 } 22462 *v = sv 22463 return nil 22464} 22465 22466func awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(v **DescribeDBParametersOutput, decoder smithyxml.NodeDecoder) error { 22467 if v == nil { 22468 return fmt.Errorf("unexpected nil of type %T", v) 22469 } 22470 var sv *DescribeDBParametersOutput 22471 if *v == nil { 22472 sv = &DescribeDBParametersOutput{} 22473 } else { 22474 sv = *v 22475 } 22476 22477 for { 22478 t, done, err := decoder.Token() 22479 if err != nil { 22480 return err 22481 } 22482 if done { 22483 break 22484 } 22485 originalDecoder := decoder 22486 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22487 switch { 22488 case strings.EqualFold("Marker", t.Name.Local): 22489 val, err := decoder.Value() 22490 if err != nil { 22491 return err 22492 } 22493 if val == nil { 22494 break 22495 } 22496 { 22497 xtv := string(val) 22498 sv.Marker = ptr.String(xtv) 22499 } 22500 22501 case strings.EqualFold("Parameters", t.Name.Local): 22502 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22503 if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { 22504 return err 22505 } 22506 22507 default: 22508 // Do nothing and ignore the unexpected tag element 22509 err = decoder.Decoder.Skip() 22510 if err != nil { 22511 return err 22512 } 22513 22514 } 22515 decoder = originalDecoder 22516 } 22517 *v = sv 22518 return nil 22519} 22520 22521func awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(v **DescribeDBSubnetGroupsOutput, decoder smithyxml.NodeDecoder) error { 22522 if v == nil { 22523 return fmt.Errorf("unexpected nil of type %T", v) 22524 } 22525 var sv *DescribeDBSubnetGroupsOutput 22526 if *v == nil { 22527 sv = &DescribeDBSubnetGroupsOutput{} 22528 } else { 22529 sv = *v 22530 } 22531 22532 for { 22533 t, done, err := decoder.Token() 22534 if err != nil { 22535 return err 22536 } 22537 if done { 22538 break 22539 } 22540 originalDecoder := decoder 22541 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22542 switch { 22543 case strings.EqualFold("DBSubnetGroups", t.Name.Local): 22544 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22545 if err := awsAwsquery_deserializeDocumentDBSubnetGroups(&sv.DBSubnetGroups, nodeDecoder); err != nil { 22546 return err 22547 } 22548 22549 case strings.EqualFold("Marker", t.Name.Local): 22550 val, err := decoder.Value() 22551 if err != nil { 22552 return err 22553 } 22554 if val == nil { 22555 break 22556 } 22557 { 22558 xtv := string(val) 22559 sv.Marker = ptr.String(xtv) 22560 } 22561 22562 default: 22563 // Do nothing and ignore the unexpected tag element 22564 err = decoder.Decoder.Skip() 22565 if err != nil { 22566 return err 22567 } 22568 22569 } 22570 decoder = originalDecoder 22571 } 22572 *v = sv 22573 return nil 22574} 22575 22576func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultClusterParametersOutput(v **DescribeEngineDefaultClusterParametersOutput, decoder smithyxml.NodeDecoder) error { 22577 if v == nil { 22578 return fmt.Errorf("unexpected nil of type %T", v) 22579 } 22580 var sv *DescribeEngineDefaultClusterParametersOutput 22581 if *v == nil { 22582 sv = &DescribeEngineDefaultClusterParametersOutput{} 22583 } else { 22584 sv = *v 22585 } 22586 22587 for { 22588 t, done, err := decoder.Token() 22589 if err != nil { 22590 return err 22591 } 22592 if done { 22593 break 22594 } 22595 originalDecoder := decoder 22596 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22597 switch { 22598 case strings.EqualFold("EngineDefaults", t.Name.Local): 22599 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22600 if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { 22601 return err 22602 } 22603 22604 default: 22605 // Do nothing and ignore the unexpected tag element 22606 err = decoder.Decoder.Skip() 22607 if err != nil { 22608 return err 22609 } 22610 22611 } 22612 decoder = originalDecoder 22613 } 22614 *v = sv 22615 return nil 22616} 22617 22618func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(v **DescribeEngineDefaultParametersOutput, decoder smithyxml.NodeDecoder) error { 22619 if v == nil { 22620 return fmt.Errorf("unexpected nil of type %T", v) 22621 } 22622 var sv *DescribeEngineDefaultParametersOutput 22623 if *v == nil { 22624 sv = &DescribeEngineDefaultParametersOutput{} 22625 } else { 22626 sv = *v 22627 } 22628 22629 for { 22630 t, done, err := decoder.Token() 22631 if err != nil { 22632 return err 22633 } 22634 if done { 22635 break 22636 } 22637 originalDecoder := decoder 22638 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22639 switch { 22640 case strings.EqualFold("EngineDefaults", t.Name.Local): 22641 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22642 if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { 22643 return err 22644 } 22645 22646 default: 22647 // Do nothing and ignore the unexpected tag element 22648 err = decoder.Decoder.Skip() 22649 if err != nil { 22650 return err 22651 } 22652 22653 } 22654 decoder = originalDecoder 22655 } 22656 *v = sv 22657 return nil 22658} 22659 22660func awsAwsquery_deserializeOpDocumentDescribeEventCategoriesOutput(v **DescribeEventCategoriesOutput, decoder smithyxml.NodeDecoder) error { 22661 if v == nil { 22662 return fmt.Errorf("unexpected nil of type %T", v) 22663 } 22664 var sv *DescribeEventCategoriesOutput 22665 if *v == nil { 22666 sv = &DescribeEventCategoriesOutput{} 22667 } else { 22668 sv = *v 22669 } 22670 22671 for { 22672 t, done, err := decoder.Token() 22673 if err != nil { 22674 return err 22675 } 22676 if done { 22677 break 22678 } 22679 originalDecoder := decoder 22680 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22681 switch { 22682 case strings.EqualFold("EventCategoriesMapList", t.Name.Local): 22683 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22684 if err := awsAwsquery_deserializeDocumentEventCategoriesMapList(&sv.EventCategoriesMapList, nodeDecoder); err != nil { 22685 return err 22686 } 22687 22688 default: 22689 // Do nothing and ignore the unexpected tag element 22690 err = decoder.Decoder.Skip() 22691 if err != nil { 22692 return err 22693 } 22694 22695 } 22696 decoder = originalDecoder 22697 } 22698 *v = sv 22699 return nil 22700} 22701 22702func awsAwsquery_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, decoder smithyxml.NodeDecoder) error { 22703 if v == nil { 22704 return fmt.Errorf("unexpected nil of type %T", v) 22705 } 22706 var sv *DescribeEventsOutput 22707 if *v == nil { 22708 sv = &DescribeEventsOutput{} 22709 } else { 22710 sv = *v 22711 } 22712 22713 for { 22714 t, done, err := decoder.Token() 22715 if err != nil { 22716 return err 22717 } 22718 if done { 22719 break 22720 } 22721 originalDecoder := decoder 22722 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22723 switch { 22724 case strings.EqualFold("Events", t.Name.Local): 22725 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22726 if err := awsAwsquery_deserializeDocumentEventList(&sv.Events, nodeDecoder); err != nil { 22727 return err 22728 } 22729 22730 case strings.EqualFold("Marker", t.Name.Local): 22731 val, err := decoder.Value() 22732 if err != nil { 22733 return err 22734 } 22735 if val == nil { 22736 break 22737 } 22738 { 22739 xtv := string(val) 22740 sv.Marker = ptr.String(xtv) 22741 } 22742 22743 default: 22744 // Do nothing and ignore the unexpected tag element 22745 err = decoder.Decoder.Skip() 22746 if err != nil { 22747 return err 22748 } 22749 22750 } 22751 decoder = originalDecoder 22752 } 22753 *v = sv 22754 return nil 22755} 22756 22757func awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(v **DescribeEventSubscriptionsOutput, decoder smithyxml.NodeDecoder) error { 22758 if v == nil { 22759 return fmt.Errorf("unexpected nil of type %T", v) 22760 } 22761 var sv *DescribeEventSubscriptionsOutput 22762 if *v == nil { 22763 sv = &DescribeEventSubscriptionsOutput{} 22764 } else { 22765 sv = *v 22766 } 22767 22768 for { 22769 t, done, err := decoder.Token() 22770 if err != nil { 22771 return err 22772 } 22773 if done { 22774 break 22775 } 22776 originalDecoder := decoder 22777 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22778 switch { 22779 case strings.EqualFold("EventSubscriptionsList", t.Name.Local): 22780 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22781 if err := awsAwsquery_deserializeDocumentEventSubscriptionsList(&sv.EventSubscriptionsList, nodeDecoder); err != nil { 22782 return err 22783 } 22784 22785 case strings.EqualFold("Marker", t.Name.Local): 22786 val, err := decoder.Value() 22787 if err != nil { 22788 return err 22789 } 22790 if val == nil { 22791 break 22792 } 22793 { 22794 xtv := string(val) 22795 sv.Marker = ptr.String(xtv) 22796 } 22797 22798 default: 22799 // Do nothing and ignore the unexpected tag element 22800 err = decoder.Decoder.Skip() 22801 if err != nil { 22802 return err 22803 } 22804 22805 } 22806 decoder = originalDecoder 22807 } 22808 *v = sv 22809 return nil 22810} 22811 22812func awsAwsquery_deserializeOpDocumentDescribeOrderableDBInstanceOptionsOutput(v **DescribeOrderableDBInstanceOptionsOutput, decoder smithyxml.NodeDecoder) error { 22813 if v == nil { 22814 return fmt.Errorf("unexpected nil of type %T", v) 22815 } 22816 var sv *DescribeOrderableDBInstanceOptionsOutput 22817 if *v == nil { 22818 sv = &DescribeOrderableDBInstanceOptionsOutput{} 22819 } else { 22820 sv = *v 22821 } 22822 22823 for { 22824 t, done, err := decoder.Token() 22825 if err != nil { 22826 return err 22827 } 22828 if done { 22829 break 22830 } 22831 originalDecoder := decoder 22832 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22833 switch { 22834 case strings.EqualFold("Marker", t.Name.Local): 22835 val, err := decoder.Value() 22836 if err != nil { 22837 return err 22838 } 22839 if val == nil { 22840 break 22841 } 22842 { 22843 xtv := string(val) 22844 sv.Marker = ptr.String(xtv) 22845 } 22846 22847 case strings.EqualFold("OrderableDBInstanceOptions", t.Name.Local): 22848 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22849 if err := awsAwsquery_deserializeDocumentOrderableDBInstanceOptionsList(&sv.OrderableDBInstanceOptions, nodeDecoder); err != nil { 22850 return err 22851 } 22852 22853 default: 22854 // Do nothing and ignore the unexpected tag element 22855 err = decoder.Decoder.Skip() 22856 if err != nil { 22857 return err 22858 } 22859 22860 } 22861 decoder = originalDecoder 22862 } 22863 *v = sv 22864 return nil 22865} 22866 22867func awsAwsquery_deserializeOpDocumentDescribePendingMaintenanceActionsOutput(v **DescribePendingMaintenanceActionsOutput, decoder smithyxml.NodeDecoder) error { 22868 if v == nil { 22869 return fmt.Errorf("unexpected nil of type %T", v) 22870 } 22871 var sv *DescribePendingMaintenanceActionsOutput 22872 if *v == nil { 22873 sv = &DescribePendingMaintenanceActionsOutput{} 22874 } else { 22875 sv = *v 22876 } 22877 22878 for { 22879 t, done, err := decoder.Token() 22880 if err != nil { 22881 return err 22882 } 22883 if done { 22884 break 22885 } 22886 originalDecoder := decoder 22887 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22888 switch { 22889 case strings.EqualFold("Marker", t.Name.Local): 22890 val, err := decoder.Value() 22891 if err != nil { 22892 return err 22893 } 22894 if val == nil { 22895 break 22896 } 22897 { 22898 xtv := string(val) 22899 sv.Marker = ptr.String(xtv) 22900 } 22901 22902 case strings.EqualFold("PendingMaintenanceActions", t.Name.Local): 22903 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22904 if err := awsAwsquery_deserializeDocumentPendingMaintenanceActions(&sv.PendingMaintenanceActions, nodeDecoder); err != nil { 22905 return err 22906 } 22907 22908 default: 22909 // Do nothing and ignore the unexpected tag element 22910 err = decoder.Decoder.Skip() 22911 if err != nil { 22912 return err 22913 } 22914 22915 } 22916 decoder = originalDecoder 22917 } 22918 *v = sv 22919 return nil 22920} 22921 22922func awsAwsquery_deserializeOpDocumentDescribeValidDBInstanceModificationsOutput(v **DescribeValidDBInstanceModificationsOutput, decoder smithyxml.NodeDecoder) error { 22923 if v == nil { 22924 return fmt.Errorf("unexpected nil of type %T", v) 22925 } 22926 var sv *DescribeValidDBInstanceModificationsOutput 22927 if *v == nil { 22928 sv = &DescribeValidDBInstanceModificationsOutput{} 22929 } else { 22930 sv = *v 22931 } 22932 22933 for { 22934 t, done, err := decoder.Token() 22935 if err != nil { 22936 return err 22937 } 22938 if done { 22939 break 22940 } 22941 originalDecoder := decoder 22942 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22943 switch { 22944 case strings.EqualFold("ValidDBInstanceModificationsMessage", t.Name.Local): 22945 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22946 if err := awsAwsquery_deserializeDocumentValidDBInstanceModificationsMessage(&sv.ValidDBInstanceModificationsMessage, nodeDecoder); err != nil { 22947 return err 22948 } 22949 22950 default: 22951 // Do nothing and ignore the unexpected tag element 22952 err = decoder.Decoder.Skip() 22953 if err != nil { 22954 return err 22955 } 22956 22957 } 22958 decoder = originalDecoder 22959 } 22960 *v = sv 22961 return nil 22962} 22963 22964func awsAwsquery_deserializeOpDocumentFailoverDBClusterOutput(v **FailoverDBClusterOutput, decoder smithyxml.NodeDecoder) error { 22965 if v == nil { 22966 return fmt.Errorf("unexpected nil of type %T", v) 22967 } 22968 var sv *FailoverDBClusterOutput 22969 if *v == nil { 22970 sv = &FailoverDBClusterOutput{} 22971 } else { 22972 sv = *v 22973 } 22974 22975 for { 22976 t, done, err := decoder.Token() 22977 if err != nil { 22978 return err 22979 } 22980 if done { 22981 break 22982 } 22983 originalDecoder := decoder 22984 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22985 switch { 22986 case strings.EqualFold("DBCluster", t.Name.Local): 22987 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22988 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 22989 return err 22990 } 22991 22992 default: 22993 // Do nothing and ignore the unexpected tag element 22994 err = decoder.Decoder.Skip() 22995 if err != nil { 22996 return err 22997 } 22998 22999 } 23000 decoder = originalDecoder 23001 } 23002 *v = sv 23003 return nil 23004} 23005 23006func awsAwsquery_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error { 23007 if v == nil { 23008 return fmt.Errorf("unexpected nil of type %T", v) 23009 } 23010 var sv *ListTagsForResourceOutput 23011 if *v == nil { 23012 sv = &ListTagsForResourceOutput{} 23013 } else { 23014 sv = *v 23015 } 23016 23017 for { 23018 t, done, err := decoder.Token() 23019 if err != nil { 23020 return err 23021 } 23022 if done { 23023 break 23024 } 23025 originalDecoder := decoder 23026 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23027 switch { 23028 case strings.EqualFold("TagList", t.Name.Local): 23029 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23030 if err := awsAwsquery_deserializeDocumentTagList(&sv.TagList, nodeDecoder); err != nil { 23031 return err 23032 } 23033 23034 default: 23035 // Do nothing and ignore the unexpected tag element 23036 err = decoder.Decoder.Skip() 23037 if err != nil { 23038 return err 23039 } 23040 23041 } 23042 decoder = originalDecoder 23043 } 23044 *v = sv 23045 return nil 23046} 23047 23048func awsAwsquery_deserializeOpDocumentModifyDBClusterEndpointOutput(v **ModifyDBClusterEndpointOutput, decoder smithyxml.NodeDecoder) error { 23049 if v == nil { 23050 return fmt.Errorf("unexpected nil of type %T", v) 23051 } 23052 var sv *ModifyDBClusterEndpointOutput 23053 if *v == nil { 23054 sv = &ModifyDBClusterEndpointOutput{} 23055 } else { 23056 sv = *v 23057 } 23058 23059 for { 23060 t, done, err := decoder.Token() 23061 if err != nil { 23062 return err 23063 } 23064 if done { 23065 break 23066 } 23067 originalDecoder := decoder 23068 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23069 switch { 23070 case strings.EqualFold("CustomEndpointType", t.Name.Local): 23071 val, err := decoder.Value() 23072 if err != nil { 23073 return err 23074 } 23075 if val == nil { 23076 break 23077 } 23078 { 23079 xtv := string(val) 23080 sv.CustomEndpointType = ptr.String(xtv) 23081 } 23082 23083 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 23084 val, err := decoder.Value() 23085 if err != nil { 23086 return err 23087 } 23088 if val == nil { 23089 break 23090 } 23091 { 23092 xtv := string(val) 23093 sv.DBClusterEndpointArn = ptr.String(xtv) 23094 } 23095 23096 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 23097 val, err := decoder.Value() 23098 if err != nil { 23099 return err 23100 } 23101 if val == nil { 23102 break 23103 } 23104 { 23105 xtv := string(val) 23106 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 23107 } 23108 23109 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 23110 val, err := decoder.Value() 23111 if err != nil { 23112 return err 23113 } 23114 if val == nil { 23115 break 23116 } 23117 { 23118 xtv := string(val) 23119 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 23120 } 23121 23122 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 23123 val, err := decoder.Value() 23124 if err != nil { 23125 return err 23126 } 23127 if val == nil { 23128 break 23129 } 23130 { 23131 xtv := string(val) 23132 sv.DBClusterIdentifier = ptr.String(xtv) 23133 } 23134 23135 case strings.EqualFold("Endpoint", t.Name.Local): 23136 val, err := decoder.Value() 23137 if err != nil { 23138 return err 23139 } 23140 if val == nil { 23141 break 23142 } 23143 { 23144 xtv := string(val) 23145 sv.Endpoint = ptr.String(xtv) 23146 } 23147 23148 case strings.EqualFold("EndpointType", t.Name.Local): 23149 val, err := decoder.Value() 23150 if err != nil { 23151 return err 23152 } 23153 if val == nil { 23154 break 23155 } 23156 { 23157 xtv := string(val) 23158 sv.EndpointType = ptr.String(xtv) 23159 } 23160 23161 case strings.EqualFold("ExcludedMembers", t.Name.Local): 23162 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23163 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 23164 return err 23165 } 23166 23167 case strings.EqualFold("StaticMembers", t.Name.Local): 23168 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23169 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 23170 return err 23171 } 23172 23173 case strings.EqualFold("Status", t.Name.Local): 23174 val, err := decoder.Value() 23175 if err != nil { 23176 return err 23177 } 23178 if val == nil { 23179 break 23180 } 23181 { 23182 xtv := string(val) 23183 sv.Status = ptr.String(xtv) 23184 } 23185 23186 default: 23187 // Do nothing and ignore the unexpected tag element 23188 err = decoder.Decoder.Skip() 23189 if err != nil { 23190 return err 23191 } 23192 23193 } 23194 decoder = originalDecoder 23195 } 23196 *v = sv 23197 return nil 23198} 23199 23200func awsAwsquery_deserializeOpDocumentModifyDBClusterOutput(v **ModifyDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23201 if v == nil { 23202 return fmt.Errorf("unexpected nil of type %T", v) 23203 } 23204 var sv *ModifyDBClusterOutput 23205 if *v == nil { 23206 sv = &ModifyDBClusterOutput{} 23207 } else { 23208 sv = *v 23209 } 23210 23211 for { 23212 t, done, err := decoder.Token() 23213 if err != nil { 23214 return err 23215 } 23216 if done { 23217 break 23218 } 23219 originalDecoder := decoder 23220 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23221 switch { 23222 case strings.EqualFold("DBCluster", t.Name.Local): 23223 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23224 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23225 return err 23226 } 23227 23228 default: 23229 // Do nothing and ignore the unexpected tag element 23230 err = decoder.Decoder.Skip() 23231 if err != nil { 23232 return err 23233 } 23234 23235 } 23236 decoder = originalDecoder 23237 } 23238 *v = sv 23239 return nil 23240} 23241 23242func awsAwsquery_deserializeOpDocumentModifyDBClusterParameterGroupOutput(v **ModifyDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23243 if v == nil { 23244 return fmt.Errorf("unexpected nil of type %T", v) 23245 } 23246 var sv *ModifyDBClusterParameterGroupOutput 23247 if *v == nil { 23248 sv = &ModifyDBClusterParameterGroupOutput{} 23249 } else { 23250 sv = *v 23251 } 23252 23253 for { 23254 t, done, err := decoder.Token() 23255 if err != nil { 23256 return err 23257 } 23258 if done { 23259 break 23260 } 23261 originalDecoder := decoder 23262 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23263 switch { 23264 case strings.EqualFold("DBClusterParameterGroupName", t.Name.Local): 23265 val, err := decoder.Value() 23266 if err != nil { 23267 return err 23268 } 23269 if val == nil { 23270 break 23271 } 23272 { 23273 xtv := string(val) 23274 sv.DBClusterParameterGroupName = ptr.String(xtv) 23275 } 23276 23277 default: 23278 // Do nothing and ignore the unexpected tag element 23279 err = decoder.Decoder.Skip() 23280 if err != nil { 23281 return err 23282 } 23283 23284 } 23285 decoder = originalDecoder 23286 } 23287 *v = sv 23288 return nil 23289} 23290 23291func awsAwsquery_deserializeOpDocumentModifyDBClusterSnapshotAttributeOutput(v **ModifyDBClusterSnapshotAttributeOutput, decoder smithyxml.NodeDecoder) error { 23292 if v == nil { 23293 return fmt.Errorf("unexpected nil of type %T", v) 23294 } 23295 var sv *ModifyDBClusterSnapshotAttributeOutput 23296 if *v == nil { 23297 sv = &ModifyDBClusterSnapshotAttributeOutput{} 23298 } else { 23299 sv = *v 23300 } 23301 23302 for { 23303 t, done, err := decoder.Token() 23304 if err != nil { 23305 return err 23306 } 23307 if done { 23308 break 23309 } 23310 originalDecoder := decoder 23311 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23312 switch { 23313 case strings.EqualFold("DBClusterSnapshotAttributesResult", t.Name.Local): 23314 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23315 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(&sv.DBClusterSnapshotAttributesResult, nodeDecoder); err != nil { 23316 return err 23317 } 23318 23319 default: 23320 // Do nothing and ignore the unexpected tag element 23321 err = decoder.Decoder.Skip() 23322 if err != nil { 23323 return err 23324 } 23325 23326 } 23327 decoder = originalDecoder 23328 } 23329 *v = sv 23330 return nil 23331} 23332 23333func awsAwsquery_deserializeOpDocumentModifyDBInstanceOutput(v **ModifyDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 23334 if v == nil { 23335 return fmt.Errorf("unexpected nil of type %T", v) 23336 } 23337 var sv *ModifyDBInstanceOutput 23338 if *v == nil { 23339 sv = &ModifyDBInstanceOutput{} 23340 } else { 23341 sv = *v 23342 } 23343 23344 for { 23345 t, done, err := decoder.Token() 23346 if err != nil { 23347 return err 23348 } 23349 if done { 23350 break 23351 } 23352 originalDecoder := decoder 23353 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23354 switch { 23355 case strings.EqualFold("DBInstance", t.Name.Local): 23356 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23357 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 23358 return err 23359 } 23360 23361 default: 23362 // Do nothing and ignore the unexpected tag element 23363 err = decoder.Decoder.Skip() 23364 if err != nil { 23365 return err 23366 } 23367 23368 } 23369 decoder = originalDecoder 23370 } 23371 *v = sv 23372 return nil 23373} 23374 23375func awsAwsquery_deserializeOpDocumentModifyDBParameterGroupOutput(v **ModifyDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23376 if v == nil { 23377 return fmt.Errorf("unexpected nil of type %T", v) 23378 } 23379 var sv *ModifyDBParameterGroupOutput 23380 if *v == nil { 23381 sv = &ModifyDBParameterGroupOutput{} 23382 } else { 23383 sv = *v 23384 } 23385 23386 for { 23387 t, done, err := decoder.Token() 23388 if err != nil { 23389 return err 23390 } 23391 if done { 23392 break 23393 } 23394 originalDecoder := decoder 23395 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23396 switch { 23397 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 23398 val, err := decoder.Value() 23399 if err != nil { 23400 return err 23401 } 23402 if val == nil { 23403 break 23404 } 23405 { 23406 xtv := string(val) 23407 sv.DBParameterGroupName = ptr.String(xtv) 23408 } 23409 23410 default: 23411 // Do nothing and ignore the unexpected tag element 23412 err = decoder.Decoder.Skip() 23413 if err != nil { 23414 return err 23415 } 23416 23417 } 23418 decoder = originalDecoder 23419 } 23420 *v = sv 23421 return nil 23422} 23423 23424func awsAwsquery_deserializeOpDocumentModifyDBSubnetGroupOutput(v **ModifyDBSubnetGroupOutput, decoder smithyxml.NodeDecoder) error { 23425 if v == nil { 23426 return fmt.Errorf("unexpected nil of type %T", v) 23427 } 23428 var sv *ModifyDBSubnetGroupOutput 23429 if *v == nil { 23430 sv = &ModifyDBSubnetGroupOutput{} 23431 } else { 23432 sv = *v 23433 } 23434 23435 for { 23436 t, done, err := decoder.Token() 23437 if err != nil { 23438 return err 23439 } 23440 if done { 23441 break 23442 } 23443 originalDecoder := decoder 23444 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23445 switch { 23446 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 23447 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23448 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&sv.DBSubnetGroup, nodeDecoder); err != nil { 23449 return err 23450 } 23451 23452 default: 23453 // Do nothing and ignore the unexpected tag element 23454 err = decoder.Decoder.Skip() 23455 if err != nil { 23456 return err 23457 } 23458 23459 } 23460 decoder = originalDecoder 23461 } 23462 *v = sv 23463 return nil 23464} 23465 23466func awsAwsquery_deserializeOpDocumentModifyEventSubscriptionOutput(v **ModifyEventSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 23467 if v == nil { 23468 return fmt.Errorf("unexpected nil of type %T", v) 23469 } 23470 var sv *ModifyEventSubscriptionOutput 23471 if *v == nil { 23472 sv = &ModifyEventSubscriptionOutput{} 23473 } else { 23474 sv = *v 23475 } 23476 23477 for { 23478 t, done, err := decoder.Token() 23479 if err != nil { 23480 return err 23481 } 23482 if done { 23483 break 23484 } 23485 originalDecoder := decoder 23486 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23487 switch { 23488 case strings.EqualFold("EventSubscription", t.Name.Local): 23489 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23490 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 23491 return err 23492 } 23493 23494 default: 23495 // Do nothing and ignore the unexpected tag element 23496 err = decoder.Decoder.Skip() 23497 if err != nil { 23498 return err 23499 } 23500 23501 } 23502 decoder = originalDecoder 23503 } 23504 *v = sv 23505 return nil 23506} 23507 23508func awsAwsquery_deserializeOpDocumentPromoteReadReplicaDBClusterOutput(v **PromoteReadReplicaDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23509 if v == nil { 23510 return fmt.Errorf("unexpected nil of type %T", v) 23511 } 23512 var sv *PromoteReadReplicaDBClusterOutput 23513 if *v == nil { 23514 sv = &PromoteReadReplicaDBClusterOutput{} 23515 } else { 23516 sv = *v 23517 } 23518 23519 for { 23520 t, done, err := decoder.Token() 23521 if err != nil { 23522 return err 23523 } 23524 if done { 23525 break 23526 } 23527 originalDecoder := decoder 23528 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23529 switch { 23530 case strings.EqualFold("DBCluster", t.Name.Local): 23531 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23532 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23533 return err 23534 } 23535 23536 default: 23537 // Do nothing and ignore the unexpected tag element 23538 err = decoder.Decoder.Skip() 23539 if err != nil { 23540 return err 23541 } 23542 23543 } 23544 decoder = originalDecoder 23545 } 23546 *v = sv 23547 return nil 23548} 23549 23550func awsAwsquery_deserializeOpDocumentRebootDBInstanceOutput(v **RebootDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 23551 if v == nil { 23552 return fmt.Errorf("unexpected nil of type %T", v) 23553 } 23554 var sv *RebootDBInstanceOutput 23555 if *v == nil { 23556 sv = &RebootDBInstanceOutput{} 23557 } else { 23558 sv = *v 23559 } 23560 23561 for { 23562 t, done, err := decoder.Token() 23563 if err != nil { 23564 return err 23565 } 23566 if done { 23567 break 23568 } 23569 originalDecoder := decoder 23570 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23571 switch { 23572 case strings.EqualFold("DBInstance", t.Name.Local): 23573 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23574 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 23575 return err 23576 } 23577 23578 default: 23579 // Do nothing and ignore the unexpected tag element 23580 err = decoder.Decoder.Skip() 23581 if err != nil { 23582 return err 23583 } 23584 23585 } 23586 decoder = originalDecoder 23587 } 23588 *v = sv 23589 return nil 23590} 23591 23592func awsAwsquery_deserializeOpDocumentRemoveSourceIdentifierFromSubscriptionOutput(v **RemoveSourceIdentifierFromSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 23593 if v == nil { 23594 return fmt.Errorf("unexpected nil of type %T", v) 23595 } 23596 var sv *RemoveSourceIdentifierFromSubscriptionOutput 23597 if *v == nil { 23598 sv = &RemoveSourceIdentifierFromSubscriptionOutput{} 23599 } else { 23600 sv = *v 23601 } 23602 23603 for { 23604 t, done, err := decoder.Token() 23605 if err != nil { 23606 return err 23607 } 23608 if done { 23609 break 23610 } 23611 originalDecoder := decoder 23612 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23613 switch { 23614 case strings.EqualFold("EventSubscription", t.Name.Local): 23615 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23616 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 23617 return err 23618 } 23619 23620 default: 23621 // Do nothing and ignore the unexpected tag element 23622 err = decoder.Decoder.Skip() 23623 if err != nil { 23624 return err 23625 } 23626 23627 } 23628 decoder = originalDecoder 23629 } 23630 *v = sv 23631 return nil 23632} 23633 23634func awsAwsquery_deserializeOpDocumentResetDBClusterParameterGroupOutput(v **ResetDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23635 if v == nil { 23636 return fmt.Errorf("unexpected nil of type %T", v) 23637 } 23638 var sv *ResetDBClusterParameterGroupOutput 23639 if *v == nil { 23640 sv = &ResetDBClusterParameterGroupOutput{} 23641 } else { 23642 sv = *v 23643 } 23644 23645 for { 23646 t, done, err := decoder.Token() 23647 if err != nil { 23648 return err 23649 } 23650 if done { 23651 break 23652 } 23653 originalDecoder := decoder 23654 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23655 switch { 23656 case strings.EqualFold("DBClusterParameterGroupName", t.Name.Local): 23657 val, err := decoder.Value() 23658 if err != nil { 23659 return err 23660 } 23661 if val == nil { 23662 break 23663 } 23664 { 23665 xtv := string(val) 23666 sv.DBClusterParameterGroupName = ptr.String(xtv) 23667 } 23668 23669 default: 23670 // Do nothing and ignore the unexpected tag element 23671 err = decoder.Decoder.Skip() 23672 if err != nil { 23673 return err 23674 } 23675 23676 } 23677 decoder = originalDecoder 23678 } 23679 *v = sv 23680 return nil 23681} 23682 23683func awsAwsquery_deserializeOpDocumentResetDBParameterGroupOutput(v **ResetDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23684 if v == nil { 23685 return fmt.Errorf("unexpected nil of type %T", v) 23686 } 23687 var sv *ResetDBParameterGroupOutput 23688 if *v == nil { 23689 sv = &ResetDBParameterGroupOutput{} 23690 } else { 23691 sv = *v 23692 } 23693 23694 for { 23695 t, done, err := decoder.Token() 23696 if err != nil { 23697 return err 23698 } 23699 if done { 23700 break 23701 } 23702 originalDecoder := decoder 23703 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23704 switch { 23705 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 23706 val, err := decoder.Value() 23707 if err != nil { 23708 return err 23709 } 23710 if val == nil { 23711 break 23712 } 23713 { 23714 xtv := string(val) 23715 sv.DBParameterGroupName = ptr.String(xtv) 23716 } 23717 23718 default: 23719 // Do nothing and ignore the unexpected tag element 23720 err = decoder.Decoder.Skip() 23721 if err != nil { 23722 return err 23723 } 23724 23725 } 23726 decoder = originalDecoder 23727 } 23728 *v = sv 23729 return nil 23730} 23731 23732func awsAwsquery_deserializeOpDocumentRestoreDBClusterFromSnapshotOutput(v **RestoreDBClusterFromSnapshotOutput, decoder smithyxml.NodeDecoder) error { 23733 if v == nil { 23734 return fmt.Errorf("unexpected nil of type %T", v) 23735 } 23736 var sv *RestoreDBClusterFromSnapshotOutput 23737 if *v == nil { 23738 sv = &RestoreDBClusterFromSnapshotOutput{} 23739 } else { 23740 sv = *v 23741 } 23742 23743 for { 23744 t, done, err := decoder.Token() 23745 if err != nil { 23746 return err 23747 } 23748 if done { 23749 break 23750 } 23751 originalDecoder := decoder 23752 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23753 switch { 23754 case strings.EqualFold("DBCluster", t.Name.Local): 23755 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23756 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23757 return err 23758 } 23759 23760 default: 23761 // Do nothing and ignore the unexpected tag element 23762 err = decoder.Decoder.Skip() 23763 if err != nil { 23764 return err 23765 } 23766 23767 } 23768 decoder = originalDecoder 23769 } 23770 *v = sv 23771 return nil 23772} 23773 23774func awsAwsquery_deserializeOpDocumentRestoreDBClusterToPointInTimeOutput(v **RestoreDBClusterToPointInTimeOutput, decoder smithyxml.NodeDecoder) error { 23775 if v == nil { 23776 return fmt.Errorf("unexpected nil of type %T", v) 23777 } 23778 var sv *RestoreDBClusterToPointInTimeOutput 23779 if *v == nil { 23780 sv = &RestoreDBClusterToPointInTimeOutput{} 23781 } else { 23782 sv = *v 23783 } 23784 23785 for { 23786 t, done, err := decoder.Token() 23787 if err != nil { 23788 return err 23789 } 23790 if done { 23791 break 23792 } 23793 originalDecoder := decoder 23794 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23795 switch { 23796 case strings.EqualFold("DBCluster", t.Name.Local): 23797 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23798 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23799 return err 23800 } 23801 23802 default: 23803 // Do nothing and ignore the unexpected tag element 23804 err = decoder.Decoder.Skip() 23805 if err != nil { 23806 return err 23807 } 23808 23809 } 23810 decoder = originalDecoder 23811 } 23812 *v = sv 23813 return nil 23814} 23815 23816func awsAwsquery_deserializeOpDocumentStartDBClusterOutput(v **StartDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23817 if v == nil { 23818 return fmt.Errorf("unexpected nil of type %T", v) 23819 } 23820 var sv *StartDBClusterOutput 23821 if *v == nil { 23822 sv = &StartDBClusterOutput{} 23823 } else { 23824 sv = *v 23825 } 23826 23827 for { 23828 t, done, err := decoder.Token() 23829 if err != nil { 23830 return err 23831 } 23832 if done { 23833 break 23834 } 23835 originalDecoder := decoder 23836 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23837 switch { 23838 case strings.EqualFold("DBCluster", t.Name.Local): 23839 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23840 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23841 return err 23842 } 23843 23844 default: 23845 // Do nothing and ignore the unexpected tag element 23846 err = decoder.Decoder.Skip() 23847 if err != nil { 23848 return err 23849 } 23850 23851 } 23852 decoder = originalDecoder 23853 } 23854 *v = sv 23855 return nil 23856} 23857 23858func awsAwsquery_deserializeOpDocumentStopDBClusterOutput(v **StopDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23859 if v == nil { 23860 return fmt.Errorf("unexpected nil of type %T", v) 23861 } 23862 var sv *StopDBClusterOutput 23863 if *v == nil { 23864 sv = &StopDBClusterOutput{} 23865 } else { 23866 sv = *v 23867 } 23868 23869 for { 23870 t, done, err := decoder.Token() 23871 if err != nil { 23872 return err 23873 } 23874 if done { 23875 break 23876 } 23877 originalDecoder := decoder 23878 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23879 switch { 23880 case strings.EqualFold("DBCluster", t.Name.Local): 23881 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23882 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23883 return err 23884 } 23885 23886 default: 23887 // Do nothing and ignore the unexpected tag element 23888 err = decoder.Decoder.Skip() 23889 if err != nil { 23890 return err 23891 } 23892 23893 } 23894 decoder = originalDecoder 23895 } 23896 *v = sv 23897 return nil 23898} 23899